前言
本文对各类排序算法的实现、优化、复杂度、稳定性、适用场景作以全面总结,为了突出算法的简洁、易懂,去除了一些冗余操作,默认为升序进行模拟。
一、插入排序
插入排序基本思想
:每一步将一个待排序的元素,按其排序码的大小,插入到前面已经排好序的一组元素的合适位置上去,直到元素插完。
☞ 直接插入排序
基本思想
:当我们插入第i(i>=1)个元素时,前面的所有元素已经排好序,此时我们使用当前元素从后向前比较,直到找到一个小于array[i]的节点(若没有,则插在数组下标为0的地方),从下一个节点顺序后移,将array[i]插入进来。
时间复杂度: O(n^2)
空间复杂度: O(1)
稳定性:稳定
适用场景
:1.数据量较小 2.基本接近有序
//直接插入排序
int InsertSort(int *num,int len)
{
assert(num);
int i = 0;
//第一个元素已经为有序序列,所以要进行len-1次排序
for (; i < len - 1; i++)
{
int end = i;
int tmp = num[i + 1];//保存非有序区间第一个元素,否则在后边的移动中会改变
//比较后移
while (end >= 0 && num[end]>tmp)
{
num[end+1] = num[end];
--end;
}
//插入到适当位置
num[end + 1] = tmp;
}
}
☞ 二分插入排序(优化)
基本思想
:在直接插入排序的基础上进行优化,因为待插入元素之前的元素已经有序,我们没必要每个都遍历,借助而二分法的思想可以有效降低查找的时间。
void BinaryInsertSort(int *arr, int size)
{
if (arr == NULL || size <= 0)
return ;
int index = 0;
for (int idx = 1; idx < size; ++idx)
{
int tmp = arr[idx];//保存待插入元素
int left = 0;
int right = idx - 1;
int mid = (left&right) + ((left^right) >> 1);
//二分法查找插入位置
while (left <= right)
{
if (tmp < arr[mid])
{
right = mid - 1;
index = mid;//更新插入位置
}
else if (tmp >= arr[mid])
{
left = mid + 1;
index = mid + 1;//更新插入位置
}
mid = (left&right) + ((left^right) >> 1);//缩小空间
}
//后移元素
for (int j = idx; j > index; j--)
{
arr[j] = arr[j - 1];
}
//插入新元素
arr[index] = tmp;
}
}
☞ 希尔排序
基本思想
:希尔排序是插入排序的一个变种。不同之处在于我们按步长gap分组,对每组的记录采用直接插入排序,随着步长的逐渐减少,分组包含的记录越来越多,直到gap=1时,构成了一个有序记录。
时间复杂度: O(n^1.25) ~ 1.6*O(n^1.25)
空间复杂度: O(1)
稳定性:不稳定
适用场景
:数据量较大,有序
下图中为了方便,对gap以gap/2来计算,但最优的算法是gap/3+1。
void ShellSort(int* arr, int size)
{
if (arr == NULL || size <= 0)
return;
int gap = size;//gap为增量
while (gap > 1)
{
gap = gap / 3 + 1;//这样给是最优的
for (int idx = gap; idx < size; ++idx)
{
int end = idx - gap;//分组后,当前元素的前一个元素
int key = arr[idx];//保存当前元素
//按升序排序
while (end >= 0 && arr[end] > key)
{
arr[end + gap] = arr[end];
end -= gap;
}
arr[end + gap] = key;
}
}
}
二、选择排序
基本思想
:每一趟(例如第i趟,i=0,1,…,n-2)在后面n-i个待排序的数据元素集合中选出关键码最小的数据元素,作为有序元素序列的第i个元素,待到第n-2趟做完,待排序元素集合中只剩 下1个元素,排序结束。
时间复杂度: O(n^2)
空间复杂度: O(1)
稳定性:不稳定
适用场景
:数据量较小,交换次数比较少
☞ 选择排序(单边缩小空间)
基本思想
:我们定义一个maxIndex来标记区间内最大值的下标,第一次遍历完数组后,更新maxIndex的指向,与下标为end(最后一个元素)的元素交换,end–缩小空间,继续遍历更新maxIndex。
void SelectSort(int* arr, int size)
{
if (arr == NULL || size <= 0)
return;
for (int end = size - 1; end > 0; --end)
{
int maxIndex = end;//最大下标
for (int idx = 0; idx < end; ++idx)
{
//比最大的元素还大,更新最大下标
if (arr[idx] > arr[maxIndex])
maxIndex = idx;
}
//交换end与最大元素的值
std::swap(arr[maxIndex], arr[end]);
}
}
☞ 选择排序(双边缩小空间1.0)
基本思想
:每一趟遍历我们需要找出最大元素的下标与最小元素的下标,然后用处于最小下标的元素与begin(首元素下标)交换,用最大下标的元素与end(尾元素下标),最后begin++,end–同时缩短区间,直到begin与end相等。
注意
:如果begin与maxIndex相同,begin与minPos交换之后,maxPos也应该指向minPos。
void SelectSort(int* arr, int size)
{
if (arr == NULL || size <= 0)
return;
int begin = 0;
int end = size - 1;
while (begin < end)
{
int maxPos = begin;//最大元素下标
int minPos = begin;//最小元素下标
for (int idx = begin + 1; idx <= end; ++idx)
{
//比最大的元素还大,更新最大下标
if (arr[idx] > arr[maxPos])
maxPos = idx;
//比最小的元素还小,更新最大下标
if (arr[idx] < arr[minPos])
minPos = idx;
}
//交换begin与最小元素的值
std::swap(arr[begin], arr[minPos]);
//如果最大元素下标与begin相同,上面begin与minPos已经交换,因此maxPos也应该指向minPos
if (maxPos == begin)
maxPos = minPos;
//交换end与最大元素的值
std::swap(arr[end], arr[maxPos]);
//缩小区间
++begin;
--end;
}
}
☞ 选择排序(双边缩小空间2.0)
基本思想
:1.0版本中,我们需要考虑最大下标与begin的重合问题,为了避免这样的问题出现,我们将不再使用maxPos和minPos,而改用直接交换数据,然后缩小空间,直到左右空间重合。
void SelectSort(int* arr, int size)
{
if (arr == NULL || size <= 0)
return;
int left = 0;
int right = size - 1;
while (left < right)
{
for (int idx = left; idx <= right; ++idx)
{
//比left小的交换
if (arr[idx] < arr[left])
std::swap(arr[idx], arr[left]);
//比right大的交换
if (arr[idx] > arr[right])
std::swap(arr[idx], arr[right]);
}
//缩小左右区间
++left;
--right;
}
}
☞ 堆排序
基本思想
:堆排序本质上是一种树形选择排序。它也是对直接选择排序的一种优化,堆结构在物理存储上也是一种数组,但是它在逻辑上是一棵完全二叉树,在进行堆排序(升序)时,我们可以先建一个大堆,最大的元素在堆顶上,我们可以以O(1)的时间找到最大的元素,然后和最后一个元素交换。此时,这个堆的左右子树仍然是一个堆,我们只要把[n-1]个数向下调整一次重新建个大堆即可,直到堆中剩下一个元素,既排序完成。
排升序–>建大堆 && 排降序–>建小堆
我们从最后一个非叶子结点建堆,步骤如下:
⑴ 将堆顶元素与当前最大堆的最后一个节点交换
⑵ 最大堆节点-1,即调整剩下的n-1个节点
⑶ 从堆顶继续向下调整,试之满足最大堆,循环⑴ ⑵ ,直至剩下一个节点。
时间复杂度: 0(NlogN)
稳定性:不稳定
适用场景
:topK问题等
void AdjustDown(int *arr, int root, int size)//建大堆
{
int parent = root;
int child = parent * 2 + 1;
while (child < size)
{
//保证child指向较大节点
if (child + 1 < size && arr[child + 1] > arr[child])
child += 1;
if (arr[child] > arr[parent])
{
std::swap(arr[child], arr[parent]);
parent = child;//下滤
child = parent * 2 + 1;
}
else
break;
}
}
//堆排序递归
void HeapSort(int *arr, int size)
{
assert(arr && size > 1);
//从最后一个非叶子节点建堆
for (int idx = (size - 2) / 2; idx >= 0; --idx)
{
AdjustDown(arr, idx, size);//下滤调整
}
int end = size - 1;
while (end > 0)
{
//堆顶与最后一个节点交换,升序
std::swap(arr[0], arr[end]);
AdjustDown(arr, 0, end);//下滤调整
--end;
}
}
四、交换排序
☞ 冒泡排序
基本思想
:一次确定一个最大值或者最小值,两两比较,将最大值或者最小交换到最右边或者最左边,N个元素需要N-1趟排序。
代码实现:
//冒泡排序
void BubbleSort(int* num, int len)
{
int flag = 0;
if (num == NULL || len <= 0)
return;
//确定循环躺数
for (int i = 0; i < len - 1; i++)
{
//确定比较次数
for (int j = 0; j < len - 1 - i; j++)
{
if (num[j]>num[j + 1])
{
Swap(&num[j], &num[j + 1]);
}
flag=1;
}
if(0 == flag)
break;
}
}
☞ 快速排序
基本思想
:在待排序序列中任意取一个元素作为基准元素,按照该基准元素将待排序序列分为两个子序列,左边子序列的值都小于基准值,右边子序列的值都大于基准值。然后把左右子序列当做一个子问题,以同样的方法处理左右子序列,直到所有的元素都排列在相对应的位置上为止。快排是一个递归问题,它是按照二叉递归树的前序路线去划分的。
关于快速排序,我详细将快排的细节总结于我的另一篇博客:快排总结
参考博客
:快排总结
五、归并排序
☞ 归并排序
基本思想
:归并排序是一个外排序,它可以对磁盘的文件进行排序。它将待排序的元素序列分成两个长度相等的子序列,对每一个子序列排序,然后在将他们合并为一个序列。合并两个子序列的过程称为二路归并。归并排序主要分为两步分组和归并。
void MergeSort(int* num, int len)
{
if (num == NULL || len <= 0)
return;
//开辟临时空间,用来存放每次合并后的子序列
int* tmp = (int*)malloc(sizeof(int)*len);
_MergeSort(num, 0, len - 1, tmp);
//释放空间
free(tmp);
tmp = NULL;
}
//归并排序分开过程(递归树按照前序路线展开)
void _MergeSort(int* num, int begin, int end,int* tmp)
{
assert(num&&tmp);
int mid = begin + (end - begin) / 2;
//只有一个元素,说明这个序列已经有序
if (begin == end)
return;
//子问题划分左子序列
_MergeSort(num, begin, mid, tmp);
//子问题划分右子序列
_MergeSort(num, mid + 1, end, tmp);
//合并两个有序数组
Merge(num, begin, mid, mid + 1, end, tmp);
}
//归并排序合并过程
void Merge(int* num, int start1, int end1, int start2, int end2, int* tmp)
{
assert(num&&tmp);
int begin = start1;
int index = start1;//从start1的地方合并
//和两条有序单链表的合并的过程类似
while ((start1 <= end1) && (start2 <= end2))
{
if (num[start1] < num[start2])
{
tmp[index++] = num[start1++];
}
else
{
tmp[index++] = num[start2++];
}
}
//把剩余的合并到tmp上
while (start1 <= end1)
tmp[index++] = num[start1++];
while (start2 <= end2)
tmp[index++] = num[start2++];
//tmp是个临时空间,最后到把合并的内容拷贝到num上
memcpy(num + begin, tmp + begin, sizeof(int)*(end2 - begin + 1));
}
参考博客
归并递归与非递归
六、计数排序
☞ 计数排序
计数排序
又称为鸽巢原理,
它是对哈希直接定址法的变形应用。计数排序是一种非比较的排序算法,其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。这说明计数排序只适合用于比较数据较为集中的数据,如果数据太过分散是非常浪费空间的。
实现步骤
- 统计所有相同数据出现的次数
- 根据统计的次数将序列放回到原来的数组返回
效率分析
计数排序是一个稳定
的排序算法。当输入的元素是 n 个 0到 k 之间的整数时,时间复杂度是O(n+k)。
空间复杂度也是(n+k),其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时,计数排序是一个很有效的排序算法
void CountSort(int* num,int len)
{
if(num==NULL||len<=0)
return;
int min=num[0],max=num[0];
int i=0;
for(;i<len;i++)
{
if(num[i]<min)
min=num[i];
if(num[i]>max)
max=num[i];
}
int range=max-min+1;
int* tmp=(int*)malloc(sizeof(int)*range);
if(tmp==NULL)
{
perror("use malloc");
exit(1);
}
memset(tmp,0,sizeof(int)*range);
for(i=0;i<len;i++)
{
tmp[num[i]-min]++;
}
int index=0;
for(i=0;i<range;i++)
{
while((tmp[i]--)!=0)
{
num[index]=i+min;
index++;
}
}
}
七、总结
术语说明
稳定
:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;
不稳定
:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;
内排序
:所有排序操作都在内存中完成;
外排序
:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;
时间复杂度
: 一个算法执行所耗费的时间。
空间复杂度
:运行完一个程序所需内存的大小。
图片名词解释:
n
: 数据规模
k
: “桶”的个数
In-place
: 占用常数内存,不占用额外内存
Out-place
: 占用额外内存
八、附加
参考博客:
GIF演示排序算法
史上最容易理解的《十大经典算法(动态图展示)》
几种排序方法动态图显示
八大排序,各显神通–动图版