算法：插入排序算法

1.插入排序

1.1 基本思想

• 每步将一个待排序的对象，按其关键码大小，插入到前面已经排好序的一组对象的适当位置上，直到全部对象插入为止。

1.2 基本操作

• 有序插入
  • 在有序序列中插入一个元素，保持序列有序，有序长度不断增加
  • 起初，a[0]是长度为1的子序列。然后，逐一将a[1]至a[n-1]插入到有序子序列中。

1.3 插入方法

• 在插入a[i]之前，数组a的前半段是有序段，后半段是停留于输入次序的无序段
  • 插入a[i]使得a[0]~a[i-1]有序，也就是要为a[i]找到有序位置j

1.4 分类

• 顺序法定位插入排序——直接插入排序
• 缩小增量多遍插入排序——希尔排序
• 二分法定位插入排序——二分插入排序

2. 直接插入排序

2.1 直接插入排序

• 直接插入排序——采用顺序查找法查找插入位置
  • 赋值插入元素。
  • 记录后移，查找插入位置。

public static void insertSort(int[] arr){
    int n = arr.length;
    for(int i=1;i<n;i++){
        for(int j=i;j>0;j--){
            if(arr[j-1]>arr[j]){
                swap(arr,j,j-1);            
            }        
        }    
    }
}
public static void swap(int[] arr,int i,int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

2.2 直接插入排序——性能分析

• 实现排序的基本操作有两个
  • 最坏的情况
    • 关键字在记录中逆序有序
      • 比较次数：(n+2)(n-1)/2
      • 移动次数：(n+4)(n-1)/2
  • 最好情况
    • 关键字在记录中顺序有序
      • 比较次数：n-1
      • 移动次数：0
  • 比较序列中两个关键字的大小。
  • 移动记录。

2.3 时间复杂度结论

• 原始数据越接近有序，排序速度越快
  • 如何提高排序效率
    • 减少元素的比较次数
    • 减少元素的移动次数
  • 平均情况下时间复杂度 O(n²)
  • 最坏情况下时间复杂度 O(n²)

3. 折半插入排序

3.1 折半插入排序

• 查找插入位置时采用折半查找法

3.2 算法描述

public static void insertSort(int[] arr){
    int n = arr.length;
    for(int i =1;i<n;i++){
        int low=0,high =i;
        while (low<=high){
            int mid = (low+high)/2;
            if(arr[mid] >arr[i] ){
                high = mid-1;
            }else if(arr[mid] < arr[i]){
                low = mid+1;
            }
        }
        swap(arr,high+1,i);
    }
}

public static void swap(int[] arr,int i,int j ){
    int temp = arr[j];
    for(;j>i;j--){
        arr[j] = arr[j-1];
    }
    arr[i] = temp;
}

3.3 折半插入排序——算法分析

• 折半查找比顺序查找快，所以折半插入排序就平均性能来说比直接插入排序要快。
  • 折半插入排序的对象移动次数与直接插入排序相同，依赖于对象的初始排列
    • 减少了比较次数，但是没有减少移动次数
    • 平均性能优于直接插入排序
      • 时间复杂度：O(n²)
      • 空间复杂度：O(1)
      • 是一种稳定的排序方法
  • 他所需要的关键码比较次数与待排序对象序列的初始排序无关，仅依赖于对象的个数。在插入第i个对象时，需要经过log(i) +1次关键码比较，才能确定他的位置
    • 当n较大时，总关键码比较次数比直接插入排序的最坏情况好得多，但比其最好情况要差
    • 在对象的初始排序已经按关键码排好序或者接近有序时，直接插入排序比折半插入排序排序执行的关键码比较的次数要少

4. 希尔排序

4.1 基本思想

• 先将整个待排记录分割成若干个子序列，分别进行直接插入排序，待整个序列中的记录基本有序时，在对全体记录进行一次直接插入排序
• 希尔排序算法特点：
  • 多遍插入排序
  • 缩小增量

4.2 希尔排序特点

• 一次移动，移动位置较大，跳跃式地接近排序后的位置
• 增量序列应该是互质的
• 增量序列必须是递减的，最后一个必须是1
• 最后一次只需要少量移动

4.3 算法描述

void ShellSort(Sqlist &L,int dlta[],int t){
    for(k=0;k<t;++k)          
    	Shelllnsert(L,dlta[k]);//一趟增量为dlta[k]的插入排序
}

void Shelllnsert(Sqlist &L,int dk){
    for(i=dk+1;i<=L.length;++i)
    	if(r[i].key<r[i-dk].key){
           	r[0]=r[i];
            	for(j=i-dk;j>0 && (r[0].key < r[j].key);j=j-dk)
             		r[j+dk] =r[j];
               	r[j+dk] = r[0]   
     	}
}

public static void shellInsert(int[] arr){
    int[] dt = {5, 3, 1};
    for(int i=0;i<dt.length;i++){
        for(int i=dt;i<n;i++){
   	for(int j = i-dt;j>=0;j -= dt){
       		if(arr[j] > arr[j+dt]){
           		int temp = arr[j];
           		arr[j] =arr[j+dt];
           		arr[j+dt]=temp;
       		}
  		 }
        }
    }
}

4.4 希尔排序-算法分析

• 希尔排序算法效率与增量序列取值有关
• 希尔排序的最后一个增量为1
• 希尔排序不适用在链式存储结构
• 空间复杂度为O(1)
• 希尔排序时间复杂度为 O(n^1.25)~O(1.6n^1.25)
• 希尔排序是一种不稳定的排序算法