插入排序 vs 希尔排序

插入排序

package Insert_Sort_Demo;

import java.util.Random;

/**
 * @Author:Allen
 * @Date:5/8/2021 1:49 PM
 */
/*插入排序：我们都排过队，一个一个按照身高得高矮去进行队伍的排列
* 每一个新插入的数字要进行比较，和之前的比较或者和之后的比较，    正好比前面的大，比后面的小
*
* */
public class Insert_Demo1 {
    public static void sort(Comparable[] arr){
        int length =arr.length;
        for(int indexI=1;indexI<length;indexI++){
            for (int indexJ=indexI;indexJ>0&&less(arr[indexJ],arr[indexJ-1]);indexJ--){
                exch(arr,indexJ,indexJ-1);
            }
        }
    }
    private static boolean less(Comparable comparableA,Comparable comparableB){
        return comparableA.compareTo(comparableB)<0;
    }
    private static void exch(Comparable[] arr,int indexI,int indexJ){
        Comparable temp=arr[indexI];
        arr[indexI]=arr[indexJ];
        arr[indexJ]=temp;
    }
    private static void show(Comparable[] arr){
        for(int index=0;index<arr.length;index++){
            System.out.print(arr[index]+" ");
        }
        System.out.println();
    }
    private static boolean isSort(Comparable[] arr){
        for (int index=1;index < arr.length;index++){
            if(less(arr[index],arr[index-1])){
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {

        Integer arr1[]={12,14,15,35,1,3,16};
        Integer[] arr = new Integer[10000];
        for (int index=0;index<10000;index++){
             arr[index]=new Random().nextInt(10000)+1;
        }
        long start = System.currentTimeMillis();
        sort(arr);
        long end = System.currentTimeMillis();
        System.out.println("耗费时间"+(end-start));
        assert isSort(arr);
        System.out.println("是否排列整齐？"+isSort(arr));
      //  show(arr);
    }
}

 

 

希尔排序

package Shell_Sort_Demo;

import java.util.Random;

/**
 * @Author:Allen
 * @Date:5/9/2021 11:12 AM
 */
public class Shell_Sort_Demo3 {
    private static void shell_sort(int [] arr){
         for(int step=arr.length/2;step>=1;step/=2){//步长的选择，一开始为总长度的一半
             for (int i =step;i<arr.length;i++){
                 int temp=arr[i];
                 int j=i-step;
                 while(j>0&&arr[j]>arr[i]){//两个相距步长的元素开始比较，如果符合条件，则交换
                     arr[i]=arr[j];
                     j-=step;
                 }
                 arr[j+step]=temp;//否则维持原状
             }
         }
    }
    public static void main(String[] args) {
       int s2[]= new int[10000];
       for (int i= 0; i<s2.length;i++){
           s2[i]=new Random().nextInt(10000)+1;
       }
//        int s2[]= {1,2,13,6,8,9,54,68,24,21};
       long start=System.currentTimeMillis();
       Shell_Sort_Demo3.shell_sort(s2);
       long end =System.currentTimeMillis();
        System.out.println("总用时："+(end-start));
        for (int i:
             s2) {
            System.out.print(i+" ");
        }
    }
}

 

 

希尔排序：5次实验，1000个随机数排列稳定在0ms（速度太快，时间靠的比较近）

插入排序：5次实验，1000个随机数排列稳定在15ms

 

书写的时候，有没有算法的流程，还是凭借记忆。

 ·按照step步长分组

 ·将每组进行插入排序操作，开头是arr[step],他与之前的arr[i-step]相对应，满足前者比后者大，在组内就交换

 · 不满足条件，返回原始数据

 

	时间复杂度	空间复杂度	排序状态
希尔排序	O（nlog2^n）	O（1）	不稳定排序
插入排序	O(N^2)	O（1）	稳定（不适合数据量大的情况）