插入排序

插入排序

直接插入排序

• 思路：将一个记录插入到长度为m的有序表中，使之仍保持有序
• 特性：
  • 时间复杂度：O(n2)
  • 空间复杂度：O(1)
  • 稳定性：稳定
• .java

//直接插入排序
public class SortInsert {
    public static void main(String[] args) {
        //从1索引处开始，将后面的元素插入到之前的有序列表中使之保持有序
        int arr[]={5,12,8,9,6,30,22};
        toSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void toSort(int[] arr) {
//        for (int i = 1; i < arr.length; i++) {
//            for(int j=i;j>0;j--){
//                if(arr[j]<arr[j-1]){
//                    int temp=arr[j];
//                    arr[j]=arr[j-1];
//                    arr[j-1]=temp;
//                }
//            }
//        }
        //外层循环定义轮次
        for (int i = 1; i < arr.length; i++) {
            int preIndex=i-1;
            int current=arr[i];
            //内层循环进行比较插入
            while (preIndex>=0&&arr[preIndex]>current){
                arr[preIndex+1]=arr[preIndex];
                preIndex--;
            }
            arr[preIndex+1]=current;
        }
    }
}

希尔排序（缩小增量排序）

• 思路：把记录按步长gap分组，对每组记录采用直接插入排序方法进行排序，随着步长逐渐减小，所分成的组包含的记录越来越多，当步长值减小到1时，整个数据合成一组，构成一组有序记录，完成排序；
• 直接插入排序实际就是步长为1的shell排序
• 步长选取：
  • 普通选取（不高效）第一次步长选取为数组长度的一半，然后依次减半
  • 可努特序列：int step=1；step=3*step+1
• 特性：
  • 时间复杂度：O(n1.3)
  • 稳定性：不稳定
• 图解
  
  .java

public class SortInsertShell {
    public static void main(String[] args) {
        int arr[]={5,12,8,9,6,30,22,-1};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void shellSort(int[] arr) {
        //step:步长:4,2,1
        /*
        //克努特序列选取步长
        int h=1;
        while (h<=arr.length/3){
            h=h*3+1;
        }
        for(int step=h; step>0; step=(step-1)/3)
        */
        for (int step=arr.length/2; step>0; step/=2) {
            //对一个步长区间进行比较 [step,arr.length)
            for (int i = step; i < arr.length; i++) {
                int current=arr[i];
                int preIndex=i-step;
                //对步长区间中具体的元素进行比较
                while(preIndex>=0&&current<arr[preIndex]){
                    arr[preIndex+step]=arr[preIndex];
                    preIndex-=step;
                }
                //此时step为一个负数，[j + step]为左区间上的初始交换值
                arr[preIndex+step]=current;
            }

        }
    }
}