重温基础算法内部排序之简单插入排序法

Posted 2022-09-07 顧棟

内部排序之简单插入排序法

它主要依靠选择和交换操作来进行排序。

主要思想

第一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小(大)元素，然后放到已排序的序列的末尾。以此类推，完成全部数据的排序。

过程演示

JAVA代码

1. 原始方式(一次排序确定一个最小值)

package sort;

public class SelectSort 
    public static void main(String[] args) 
        int[] o = 7, 6, 9, 3, 1, 5, 2, 4, 8;

        System.out.print("排序前: ");
        for (int t : o) 
            System.out.print(t);
            System.out.print(" ");
        
        System.out.println();

       	// 算法部分
        int minIndex;
        int temp;
        for (int i = 1; i < o.length; i++) 
            minIndex = i - 1;
            for (int j = i; j < o.length; j++) 
                if (o[minIndex] > o[j]) 
                    minIndex = j;
                
            

            if (minIndex != i - 1) 
                temp = o[i - 1];
                o[i - 1] = o[minIndex];
                o[minIndex] = temp;
            

            System.out.print("第" + i + "趟排序后: ");
            for (int t : o) 
                System.out.print(t);
                System.out.print(" ");
            
            System.out.println();
        

        System.out.print("排序后: ");
        for (int t : o) 
            System.out.print(t);
            System.out.print(" ");
        
        System.out.println();
    


    private static void c(int... o) 
        int left = 0;
        int right = o.length - 1;
        int count = 1;
        while (left < right) 
            int minIndex = left;
            int maxIndex = right;
            for (int i = left + 1; i <= right; i++) 
                if (o[i] < o[minIndex]) 
                    minIndex = i;
                
                if (o[i] > o[maxIndex]) 
                    maxIndex = i;
                
            

            int temp;
            if (minIndex != left) 
                temp = o[left];
                o[left] = o[minIndex];
                o[minIndex] = temp;
            

            if (maxIndex != right) 
                temp = o[right];
                o[right] = o[maxIndex];
                o[maxIndex] = temp;
            
            left++;
            right--;

            System.out.print("第" + count++ + "趟排序后: ");

            for (int t : o) 
                System.out.print(t);
                System.out.print(" ");
            
            System.out.println();
        

    

运行结果

排序前: 7 6 9 3 1 5 2 4 8 
第1趟排序后: 1 6 9 3 7 5 2 4 8 
第2趟排序后: 1 2 9 3 7 5 6 4 8 
第3趟排序后: 1 2 3 9 7 5 6 4 8 
第4趟排序后: 1 2 3 4 7 5 6 9 8 
第5趟排序后: 1 2 3 4 5 7 6 9 8 
第6趟排序后: 1 2 3 4 5 6 7 9 8 
第7趟排序后: 1 2 3 4 5 6 7 9 8 
第8趟排序后: 1 2 3 4 5 6 7 8 9 
排序后: 1 2 3 4 5 6 7 8 9 

2. 比较次数减半（同时安排最大最小值）

package sort;

public class SelectSort 
    public static void main(String[] args) 
        int[] o = 7, 6, 9, 3, 1, 5, 2, 4, 8;

        System.out.print("排序前: ");
        for (int t : o) 
            System.out.print(t);
            System.out.print(" ");
        
        System.out.println();

       	// 算法部分
        int left = 0;
        int right = o.length - 1;
        int count = 1;
        while (left < right) 
            int minIndex = left;
            int maxIndex = right;
            for (int i = left + 1; i <= right; i++) 
                if (o[i] < o[minIndex]) 
                    minIndex = i;
                
                if (o[i] > o[maxIndex]) 
                    maxIndex = i;
                
            

            int temp;
            if (minIndex != left) 
                temp = o[left];
                o[left] = o[minIndex];
                o[minIndex] = temp;
            

            if (maxIndex != right) 
                temp = o[right];
                o[right] = o[maxIndex];
                o[maxIndex] = temp;
            
            left++;
            right--;

            System.out.print("第" + count++ + "趟排序后: ");

            for (int t : o) 
                System.out.print(t);
                System.out.print(" ");
            
            System.out.println();
        

        System.out.print("排序后: ");
        for (int t : o) 
            System.out.print(t);
            System.out.print(" ");
        
        System.out.println();
    

运行结果

排序前: 7 6 9 3 1 5 2 4 8 
第1趟排序后: 1 6 8 3 7 5 2 4 9 
第2趟排序后: 1 2 4 3 7 5 6 8 9 
第3趟排序后: 1 2 3 4 6 5 7 8 9 
第4趟排序后: 1 2 3 4 5 6 7 8 9 
排序后: 1 2 3 4 5 6 7 8 9 

算法分析

根据上述的原理可知，一个具有n个元素的序列需要进行$n-1$趟排序，第$i$趟需要进行$n-i$次比较，因此一共需要$\sum _{i=1}^{n}i-1=(i-1)(n-1)+(n-2)+\cdot \cdot \cdot +1=n(n-1)/2$次比较。而每一趟要么交换元素、要么不交换元素，因此最好情况下（原序列中的元素在排序前就已经是有序的了）共需0次交换，最坏情况下共需n-1次交换。因此时间复杂度为$O(n^2)$。

简单选择排序只需要几个固定的额外空间用于一些临时变量，它和原序列的长度无关。因此，简单选择排序的空间复杂度为$O(1)$。