列出八大排序算法的时间复杂度:
直接插入排序(Insertion Sort)
插入排序的设计初衷是往有序的数组中快速插入一个新的元素。它的算法思想是:把要排序的数组分为了两个部分, 一部分是数组的全部元素(除去待插入的元素), 另一部分是待插入的元素; 先将第一部分排序完成, 然后再插入这个元素. 其中第一部分的排序也是通过再次拆分为两部分来进行的.
插入排序由于操作不尽相同, 可分为 直接插入排序
, 折半插入排序
(又称二分插入排序), 链表插入排序
, 希尔排序
。我们先来看下直接插入排序。
-
基本思想:
直接插入排序的基本思想是:将数组中的所有元素依次跟前面已经排好的元素相比较,如果选择的元素比已排序的元素小,则交换,直到全部元素都比较过为止。
-
算法描述:
一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:
①. 从第一个元素开始,该元素可以认为已经被排序
②. 取出下一个元素,在已经排序的元素序列中从后向前扫描
③. 如果该元素(已排序)大于新元素,将该元素移到下一位置
④. 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
⑤. 将新元素插入到该位置后
⑥. 重复步骤②~⑤
算法实现中比较有意思的一点是,在每次比较操作发现取出来的新元素小于等于已排序的元素时,可以将已排序的元素移到下一位置,然后将取出来的新元素插入该位置(即相邻位置对调),接着再与前面的已排序的元素进行比较,如上图所示,这样做缺点是交换操作代价比较大。另一种做法是:将新元素取出(挖坑),从左到右依次与已排序的元素比较,如果已排序的元素大于取出的新元素,那么将该元素移动到下一个位置(填坑),接着再与前面的已排序的元素比较,直到找到已排序的元素小于等于新元素的位置,这时再将新元素插入进去。就像基本思想中的动图演示的那样。
如果比较操作的代价比交换操作大的话,可以采用二分查找法来减少比较操作的数目。可以认为是插入排序的一个变种,称为二分查找插入排序。
-
代码实现:
public class insertionSortAlgorithms {
public static void main(String[] args) {
int[] arr1= {1,6,8,7,4,5,2,3};
System.out.println("直接插入排序");
insertionSort1(arr1);
int[] arr2= {1,6,8,7,4,5,2,3};
System.out.println("直接插入排序-交换次数较多");
insertionSort2(arr2);
}
/**
* 插入排序
* 1. 从第一个元素开始,该元素可以认为已经被排序
* 2. 取出下一个元素,在已经排序的元素序列中从后向前扫描
* 3. 如果该元素(已排序)大于新元素,将该元素移到下一位置
* 4. 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
* 5. 将新元素插入到该位置后
* 6. 重复步骤2~5
* @param arr 待排序数组
*/
public static void insertionSort1(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int temp = arr[i]; // 取出下一个元素,在已经排序的元素序列中从后向前扫描
for (int j = i; j >= 0; j--) {
if (j > 0 && arr[j - 1] > temp) {
arr[j] = arr[j - 1]; // 如果该元素(已排序)大于取出的元素temp,将该元素移到下一位置
System.out.println("Temping: " + Arrays.toString(arr));
} else {
// 将新元素插入到该位置后
arr[j] = temp;
System.out.println("Sorting: " + Arrays.toString(arr));
break;
}
}
}
}
// 交换次数较多的实现
public static void insertionSort2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j > 0; j--) {
if (arr[j - 1] <= arr[j])
break;
int temp = arr[j]; // 交换操作
arr[j] = arr[j - 1];
arr[j - 1] = temp;
System.out.println("Sorting: " + Arrays.toString(arr));
}
}
}
}
结果:
直接插入排序
Sorting: [1, 6, 8, 7, 4, 5, 2, 3]
Sorting: [1, 6, 8, 7, 4, 5, 2, 3]
Temping: [1, 6, 8, 8, 4, 5, 2, 3]
Sorting: [1, 6, 7, 8, 4, 5, 2, 3]
Temping: [1, 6, 7, 8, 8, 5, 2, 3]
Temping: [1, 6, 7, 7, 8, 5, 2, 3]
Temping: [1, 6, 6, 7, 8, 5, 2, 3]
Sorting: [1, 4, 6, 7, 8, 5, 2, 3]
Temping: [1, 4, 6, 7, 8, 8, 2, 3]
Temping: [1, 4, 6, 7, 7, 8, 2, 3]
Temping: [1, 4, 6, 6, 7, 8, 2, 3]
Sorting: [1, 4, 5, 6, 7, 8, 2, 3]
Temping: [1, 4, 5, 6, 7, 8, 8, 3]
Temping: [1, 4, 5, 6, 7, 7, 8, 3]
Temping: [1, 4, 5, 6, 6, 7, 8, 3]
Temping: [1, 4, 5, 5, 6, 7, 8, 3]
Temping: [1, 4, 4, 5, 6, 7, 8, 3]
Sorting: [1, 2, 4, 5, 6, 7, 8, 3]
Temping: [1, 2, 4, 5, 6, 7, 8, 8]
Temping: [1, 2, 4, 5, 6, 7, 7, 8]
Temping: [1, 2, 4, 5, 6, 6, 7, 8]
Temping: [1, 2, 4, 5, 5, 6, 7, 8]
Temping: [1, 2, 4, 4, 5, 6, 7, 8]
Sorting: [1, 2, 3, 4, 5, 6, 7, 8]
直接插入排序-交换次数较多
Sorting: [1, 6, 7, 8, 4, 5, 2, 3]
Sorting: [1, 6, 7, 4, 8, 5, 2, 3]
Sorting: [1, 6, 4, 7, 8, 5, 2, 3]
Sorting: [1, 4, 6, 7, 8, 5, 2, 3]
Sorting: [1, 4, 6, 7, 5, 8, 2, 3]
Sorting: [1, 4, 6, 5, 7, 8, 2, 3]
Sorting: [1, 4, 5, 6, 7, 8, 2, 3]
Sorting: [1, 4, 5, 6, 7, 2, 8, 3]
Sorting: [1, 4, 5, 6, 2, 7, 8, 3]
Sorting: [1, 4, 5, 2, 6, 7, 8, 3]
Sorting: [1, 4, 2, 5, 6, 7, 8, 3]
Sorting: [1, 2, 4, 5, 6, 7, 8, 3]
Sorting: [1, 2, 4, 5, 6, 7, 3, 8]
Sorting: [1, 2, 4, 5, 6, 3, 7, 8]
Sorting: [1, 2, 4, 5, 3, 6, 7, 8]
Sorting: [1, 2, 4, 3, 5, 6, 7, 8]
Sorting: [1, 2, 3, 4, 5, 6, 7, 8]
直接插入排序复杂度如下:
- 最好情况下,排序前对象已经按照要求的有序。比较次数(KCN):n−1n−1;移动次数(RMN)为00。则对应的时间复杂度为O(n)O(n)。
- 最坏情况下,排序前对象为要求的顺序的反序。第i趟时第i个对象必须与前面i个对象都做排序码比较,并且每做1次比较就要做1次数据移动(从上面给出的代码中看出)。比较次数(KCN):∑n−1i=1i=n(n−1)2≈n22∑i=1n−1i=n(n−1)2≈n22 ; 移动次数(RMN)为:∑n−1i=1i=n(n−1)2≈n22∑i=1n−1i=n(n−1)2≈n22。则对应的时间复杂度为O(n2)O(n2)。
- 如果排序记录是随机的,那么根据概率相同的原则,在平均情况下的排序码比较次数和对象移动次数约为n22n22,因此,直接插入排序的平均时间复杂度为O(n2)O(n2)。
平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 |
---|---|---|---|
O(n²) | O(n) | O(n²) | O(1) |
Tips: 由于直接插入排序每次只移动一个元素的位, 并不会改变值相同的元素之间的排序, 因此它是一种稳定排序。