概念:
插入排序是一种简单直观的排序方法,其基本思想在于每次将一个待排序的记录,按其关键字大小插入到前面已经排好序的子序列中,直到全部记录插入完成。
由插入排序的思想可以引申出三个重要的排序算法:直接插入排序,折半插入排序和希尔排序。
- 直接插入排序
思想:为了实现对L[1…n]的排序,可以将L(2)~L(n)依次插入到前面已经排好序的子序列中,初始假定L(1)是一个已经排好序的子序列。上述操作执行n-1次后就能得到一个有序表。插入爱旭在是现场通常采用就地排序(空间复杂度为O(1)),因而再从后往前的比较过程中,需要反复把一排好序的元素逐步向后挪威,为新元素提供插入空间。
- java代码实现:
import java.util.Arrays;
/**
* @author:cch
* @description:直接插入排序
* @date 2020/12/15
*/
public class InsertSort {
public static void main(String[] args) {
int[] numberArr = new int[] {3,1,8,9,0,23,7};
// 从第二个数开始
for (int i = 1; i < numberArr.length; i ++) {
// 待插入数据
int insertValue = numberArr[i];
// 前一位置作为索引
int insertIndex = i - 1;
// 索引值大于等于0,防止越界,同时索引位置数据大于待插入数据,索引位置数据后移,同时索引迁移
while (insertIndex >= 0 && insertValue < numberArr[insertIndex]) {
numberArr[insertIndex + 1] = numberArr[insertIndex];
insertIndex --;
}
// 待插入数据归位
numberArr[insertIndex + 1] = insertValue;
}
System.out.println(Arrays.toString(numberArr));
}
}
- 性能分析:
空间效率:仅使用了常数个辅助单元,因而空间复杂度为O(1)。
时间效率:在排序过程中,向有序子表中逐个地插入元素的操作进行了n-1趟,每趟操作都分为比较关键字和移动元素,而比较次数和一动次数取决于待排序表的初始状态。
最好的情况:表中的元素已经有序,此时没插入一个元素,都只需要比较一次而不用移动元素,因而时间复杂度为O(n)。
最坏的情况:表中元素的顺序刚好与排序结果中元素相反(逆序)时,总的比较次数最大。 - 稳定性
由于没每次插入元素时是从后往前先比较在移动,所以不会出现相同元素相应位置发生变化的情况,即直接插入排序是一个稳定的排序方法。 - 适用性
直接插入排序算法适用于顺序存储和链式存储的线性表。党委链式存储时,可以从前往后查找指定元素的位置。注意:大部分排序算法都仅适用于顺序存储的线性表。
- 折半插入排序
思想:从前面的直接插入排序算法中,不难看出每趟插入的过程中,都进行了两项工作:
①从前面的子表中查找处待插入元素应该被插入的位置;
②给插入为止腾出空间,将待插入元素复制到表中的插入位置。
注意到该算法中,总是边比较边移动元素,下面将比较合移动的操作分离出来,即先折半查找出元素待插入的位置,然后再统一地移动带插入位置之后的所有元素。当排序表为顺序存储的线性表时,可以对直接插入排序算法做如下改进:
- java代码实现:
/**
* @author:cch
* @description:折半查找
* @date 2020/12/15
*/
public class BinarySearch {
public static void main(String[] args) {
BinarySearch binarySearch = new BinarySearch();
int[] arr = {1,3,6,9,12,23,33,44,45,67,78,98,100,111,123,1234,2345,9999,11111,12345,666666,900000};
int res = binarySearch.binarySearch(arr, 44);
System.out.println("res=" + res);
}
/**
* 二分查找
* @param arr 要进行查找的数组,要求数组必须是有序的
* @param findElem 要查找的元素
* @return 返回要查找的元素在数组的索引位置, 返回-1表示没找到
*/
public int binarySearch(int[] arr, int findElem) {
int low = 0;
int high = arr.length - 1;
int mid;
while (low <= high) {
mid = (low + high) / 2;
//如果要查找的元素findElem小于中间位置的元素mid,指向数组的较大端的high索引重新指向中间索引mid的左边(mid-1)
if (findElem < arr[mid]) {
high = mid - 1;
}
//如果要查找的元素findElem大于中间位置的元素mid,指向数组的较小端的low索引重新指向中间索引mid的右边(mid+1)
if (findElem > arr[mid]) {
low = mid + 1;
}
if (arr[mid] == findElem) {
return mid;
}
}
return -1;
}
}
- 总结:
- 从上述算法中,不难看出折半插入排序仅仅是减少了比较元素的次数,该比较次数与待排序表的初始状态无关,仅取决于表中的元素个数n;而元素的一动次数没有改变,它依赖于待排序表的初始状态。时间复杂度为O(n^2)。折半插入排序是一个稳定的排序算法。
- 希尔排序
从前面的讲解不难看出,直接插入排序算法适用于基本有序的排序表和数量不大的排序表。基于这两点,1959年D.L.Shell提出了希尔排序,又称为缩小增量排序。
希尔排序的基本思想是:先将待排序的表分割成若干个形如L[i,i+d,i+2d,…i+kd]的“特殊”字表,分别进行直接插入排序,当整个表中的元素已呈“基本有序”时,再对全体记录进行一次直接插入排序。
例如,假设有这样一组数[ 12 15 80 12 90 23 13 80 26 25 14 40 21 3 35]。如果我们以步长为5开始进行排序,我们可以通过将这列表放在有5列的表中来更好地描述算法,这样他们就应该看起来是这样(竖着的元素是步长组成):
12 15 80 12 90
23 13 80 26 21
14 40 25 3 35
然后我们对每列进行排序:
12 13 25 3 21
14 15 80 12 35
23 40 80 26 90
45
将上述四行数字,依序接在一起时我们得到:[ 12 13 25 3 21 14 15 80 12 35 23 40 80 26 90 45 ]。这时10已经移至正确位置了,然后再以3为步长进行排序:
12 13 25
3 21 14
15 80 12
35 23 40
80 26 90
45
排序之后变为:
3 13 12
12 15 14
15 23 25
35 26 40
45 80 90
80
最后以1步长进行排序(此时就是简单的插入排序了)
3 12 12 13 14 15 21 23 25 26 35 40 45 80 80 90
- java代码实现:
/**
* @author:cch
* @description:希尔排序
* @date 2020/12/15
*/
public class ShellSort {
public static void main(String[] args)
{
int[] ins = {12,15,80,12,90,23,13,80,26,25,14,40,21,3,35};
int[] ins2 = sort(ins);
for(int in: ins2){
System.out.println(in);
}
}
public static int[] sort(int[] ins){
int n = ins.length;
int gap = n/2;
while(gap > 0){
for(int j = gap; j < n; j++){
int i=j;
while(i >= gap && ins[i-gap] > ins[i]){
int temp = ins[i-gap]+ins[i];
ins[i-gap] = temp-ins[i-gap];
ins[i] = temp-ins[i-gap];
i -= gap;
}
}
gap = gap/2;
}
return ins;
}
}
- 性能分析:
空间效率:仅使用了常熟个辅助单元,因而空间复杂度为O(1)
时间效率:当n在某个特定范围时,西尔艾徐的时间复杂度约为O(n1.3),最坏的情况下希尔爱虚的时间复杂度为O(n2)。 - 稳定性:当相同官架子的记录被划分到不同的子表时,可能会改变他们之前的相对次序,因此,希尔排序是一个不稳定的排序方法。
- 适用性:希尔排序算法仅适用于当线性表为顺序存储的情况。