插入排序主要包括三个:直接插入排序、折半插入排序和希尔排序。基本思想都是:
每次将一个待排序的记录,按其关键字大小插入到前面已经排好序的子序列中,直到全部记录插入完成。
下面依次进行讲解并编程实现。
直接插入排序
主要思想:
1. 循环i从1~n-1
,每次循环执行步骤2-4。
2. 查找arr[i]
在arr[0]~arr[i-1]
的插入位置k。
3. 将arr[k]~arr[i-1]
每个元素后移一个位置。
4. 将arr[i]
复制到arr[k]
。
如图所示:
时间复杂度:
- 最好情况下,每次循环只需和
arr[i-1]
比较,并不用移动,为 O(n) 。 - 最差情况下,下标为i的元素要和前面i个元素都比较一下,则一共比较次数为 ∑n−1i=1i ,即 (n2−n)/2 次;移动次数也最大,为 ∑n−1i=1i+1 ,因为还有基准元素赋到第一位,所以多了1,复杂度为 O(n2) 。
平均下来,约为
((n2+n)/4)
次,复杂度为
O(n2)
。
稳定性:稳定
适用性:用顺序表时,从后往前比较,比较后直接交换;单链表的话,从前往后查找。
不带哨兵
核心代码如下:
void insertSort(int arr[], int n)
{
int i, j;
int tmp;
for (i = 1; i < n; ++i){
if (arr[i] < arr[i - 1]){
tmp = arr[i];
for (j = i - 1; tmp < arr[j] && j>=0; --j)
arr[j + 1] = arr[j];
arr[j + 1] = tmp;
}
}
}
带哨兵
更一般的,可以引入哨兵arr[0]
,(哨兵:简化边界条件而引入的附加结点)有两个作用:
1. 可以减少临界的比较,即不用比较j>=0
2. 暂时存放待插入的元素
如下:
void insertSort(int arr[], int n)//这里n是待排序数个数,不包括哨兵
{
int i, j;
for (i = 2; i <= n; ++i){
if (arr[i] < arr[i - 1]){
arr[0] = arr[i];
for (j = i - 1; arr[0] < arr[j]; --j)
arr[j + 1] = arr[j];
arr[j + 1] = arr[0];
}
}
}
拓展:元素为结构时
如果待排序的是结构的话,也一样:
#include <iostream>
using namespace std;
struct Elem
{
int key;
Elem(){}
Elem(int key) :key(key){}
bool operator < (const Elem& other)
{
return this->key < other.key;//升序排列
}
Elem& operator = (const Elem& other)
{
this->key = other.key;
return *this;
}
friend ostream& operator << (ostream &stream, const Elem &e)
{
stream << e.key;
return stream;
}
};
void print(Elem arr[], int n, int i)
{
cout << "第" << i << "轮:";
for (int i = 0; i < n; ++i){
cout << " " << arr[i];
}
cout << endl;
}
void insertSort(Elem arr[], int n)
{
int i, j;
for (i = 2; i <= n; ++i){
if (arr[i] < arr[i - 1]){
arr[0] = arr[i];
for (j = i - 1; arr[0] < arr[j]; --j)
arr[j + 1] = arr[j];
arr[j + 1] = arr[0];
}
print(arr, n+1, i-1);
}
}
int main()
{
Elem arr[9] = { { 0 },{ 6 }, { 5 }, { 3 }, { 1 }, { 8 }, { 7 }, { 2 }, { 4 } };
print(arr, 9, 0);
insertSort(arr, 8);
system("pause");
}
第0轮: 0 6 5 3 1 8 7 2 4
第1轮: 5 5 6 3 1 8 7 2 4
第2轮: 3 3 5 6 1 8 7 2 4
第3轮: 1 1 3 5 6 8 7 2 4
第4轮: 1 1 3 5 6 8 7 2 4
第5轮: 7 1 3 5 6 7 8 2 4
第6轮: 2 1 2 3 5 6 7 8 4
第7轮: 4 1 2 3 4 5 6 7 8
折半插入排序
思路是:由于前一部分是已排序的,所以不再一次次比较,而是二分查找到待插入元素应该在哪个位子,再插入,后移操作统一放到一起。
void insertSort(int arr[], int n)
{
int i, j, low, mid, high;
for (i = 2; i <= n; ++i){
arr[0] = arr[i];
low = 1; high = i - 1;
while (low <= high){
mid = (low + high) / 2;
if (arr[mid] > arr[0])
high = mid - 1;
else low = mid + 1;//相等的话,插到后面,算法稳定
}
for (j = i - 1; j>=high+1 ; --j)//high+1到i-1的数后移
arr[j + 1] = arr[j];
arr[high + 1] = arr[0];//待插入数放到high+1
}
}
用了二分查找仅减少了比较的复杂度,从
O(n2)
到
O(nlog2n)
,且次数与数列初始状态无关,仅取决于个数n,即最好情况最差情况都是这么多。
移动次数仍然一样,但移动次数与数列初始状态有关,最好情况为0,最差情况复杂度为
O(n2)
;
故总的来说,时间复杂度
- 最好情况为 O(nlog2n) ,仅用在查找,不移动。
- 最差情况为 O(n2) ,移动+查找。
平均为
O(n2)
。
稳定性:稳定。
空间复杂度:
O(1)
希尔排序
基本思路:先将待排序表分割成若干个形如
L[i,i+d,i+2d,...i+kd]
的特殊子表,分别进行直接插入排序,随着
d
不断减小至1,整个表也会趋向于“基本有序”,最后
和直接插入相比,算法修改为:
1. 前后比较增量为dk,不是1。
2. arr[0]不再是哨兵,而仅作为暂时存储用,即判断越界用不到了。
void shellSort(int arr[], int n)
{
int dk, i, j;//dk为增量
for (dk = n / 2; dk >= 1; dk = dk / 2){
for (i = dk + 1; i <= n; ++i){
if (arr[i] < arr[i - dk]){
arr[0] = arr[i];
for (j = i - dk; j>0 && arr[0]<arr[j]; j -= dk)
arr[j + dk] = arr[j];
arr[j + dk] = arr[0];
}
}
}
}
空间复杂度:用了3个辅助单元,为
O(1)
时间复杂度:依赖于增量序列的函数。
稳定性:不稳定。
适用性:仅适用于顺序存储的线性表。(因为增量不为1,要能以常数时间访问到任何一个元素,链式就不行了。)
各算法复杂度表
算法 | 平均时间复杂度 | 最好时间复杂度 | 最差时间复杂度 | 空间复杂度 | 稳定性 | 备注 |
---|---|---|---|---|---|---|
直接插入排序 | O(n2) | O(n) | O(n2) | O(1) | 稳定 | |
折半插入排序 | O(n2) | O(nlog2n) | O(n2) | O(1) | 稳定 | |
shell排序 | O(n1.3) | O(n) | O(n2) | O(1) | 不稳定 | 和增量序列有关 |