目录
一、直接插入排序
二、希尔排序
三、选择排序
四、堆排序
五、冒泡排序
六、快速排序
1、递归版本
1.1 hoare 法
1.2 挖坑法
1.3 前后指针法
2、非递归版本
3、快速排序的优化
3.1 三数取中
3.2 小区间优化
七、归并排序
1、递归版本
2、非递归版本
八、计数排序
动图演示:
思路:(1)首先先按一趟插入排序编写, 数组的最后一个元素为 end,将要插入数据就是临时数据tmp = a[end+1],如果 tmp 小于 end 位置的数据,就将 end 位置的数据往后挪到 end+1的位置,直到插入到里面;(2)再按整体插入排序,进行插入,假设第一次数组里面就一个数据,所以 end 位置就是0,然后结束条件就是小于 n-1,否则就越界。
注意:先保存一下 end+1 位置的数据,否则在挪动的时候,就会被覆盖。
上面给出了两个动图演示,能更好的理解。
//插入排序 时间复杂度:O(N^2)
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
int end = i;
int tmp = a[end + 1];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}
希尔排序可以缩小增量排序,又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成 几个 组,所有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工 作。当到达 gap=1时,所有记录在统一组内排好序。
希尔排序的特性总结:
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序,目的是让数组更接近于有序。当gap == 1时,数组已经接近有序的了,这样就 会很快。这样整体而言,可以达到优化的效果。我们实现后可以进行性能测试的对比。
- 希尔排序的时间复杂度不好计算,因为gap的取值方法很多,导致很难去计算,因此在好多树中给出的希尔排序的时间复杂度都不固定。
//希尔排序 时间复杂度:O(N^1.3)
void ShellSort(int* a, int n)
{
//gap > 1 预排序
//gap越大,大的数可以更快的到后面,小的数可以更快的到前面。越不接近有序。
//gap越小,数据跳动越慢,越接近有序。
//gap == 1 直接插入排序
int gap = n;
while (gap > 1)
{
gap = gap / 2;
//gap = gap / 3 + 1;
for (int j = 0; j < gap; j++)//分gap组排序
{
for (int i = j; i < n - gap; i += gap)//每一个组进行插入排序
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
}
动图演示:
思路:设两个变量mini,maxi分别存最小数据位置的下标和最大位置数据的下标,每次遍历数组标记出最大数据的下标和最小位置数据的下标,分别将其与最后一个数据和开头数据进行交换。
//选择排序 时间复杂度:O(N^2)
//和直接插入排序相比,插入排序更好
//插入适应性很强,对于有序,局部有序,都能效率提升
void SelectSort(int* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int mini = begin, maxi = begin;
for (int i = begin + 1; i <= end; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if (a[i] > a[maxi])
{
maxi = i;
}
}
//此时,已经选出了最大的,和最小的
//位置交换
Swap(&a[begin], &a[mini]);
//begin跟maxi重叠了,第一步交换之后maxi位置变了
if (maxi == begin)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
注意:这种情况是特殊情况,最大值的位置(maxi)在 begin 处,交换完 a[begin] 和 a[mini] 时,此时 ,maxi 位置被交换到 mini 的位置了,所以 maxi 的位置发生了变化,需要我们处理一下 maxi 的位置。
堆排序是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆,排降序建小堆。本文建的是大堆,排升序。
//堆排序 时间复杂度:O(N*logN)
//交换
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//向下调整
void AdjustDown(int* a, int n, int parent)//n为数组的大小
{
int child = parent * 2 + 1;//左孩子
while (child < n)
{
//确认child指向大的那个孩子
if (child + 1 < n && a[child + 1] > a[child])//child+1 < n 右孩子存在的情况
{
++child;//默认指向左孩子,++child就指向右孩子
}
//孩子大于父亲,交换,继续向下调整
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;//孩子小于父亲,跳出循环
}
}
}
void HeapSort(int* a, int n)
{
//向下调整建堆--- O(N) --- 好一点
//升序:建大堆
for (int i = (n - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, n, i);
}
//O(N*logN)
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}
动图演示:
思路:前后数据进行对比,若前面数据大于后面的数据就交换,这样经过第一轮的排序,最大值就被换到了最后的位置,然后再进行第二轮排序,这样以此往复,第二大的数据被放到倒数第二的位置,直到所有数据排序完毕。
//冒泡排序 时间复杂度:O(N^2)
void BubbleSort(int* a, int n)
{
for (int j = 0; j < n; j++)
{
int exchange = 0;
for (int i = 1; i < n - j; i++)
{
if (a[i - 1] > a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 1;
}
}
//一趟冒泡过程中,没有发生交换,说明已经有序了,不需要进行处理
if (exchange == 0)
{
break;
}
}
}
基本思想为:任取待排序元素序列中 的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右 子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止。
快速排序的阶段性结果特点:第 i 趟完成时,会有 i 个以上的数据出现在它最终要出现的位置。
动图演示:
思路:(1)选取key位置,通常选在最开始的left位置(或最后面right位置)。
(2)如果key选在left位置,则 right 先走,找到比 key 位置小的数据停下。
(3)left 再走,找到比 key 位置大的数据停下。
(4)交换 left 和 right 位置的数据,一直重复以上操作,直到left 和 right 相遇结束。
(5)相遇结束后,此时交换 key 位置和 left 位置(就是相遇的位置)的数据, 这个时候相遇位置的左边的数据小于等于相遇位置的数据,右边的数据大于等于相遇位置的数据。所以,这个数据就调整到了它的正确位置。
//Hoare
int PartSort1(int* a, int begin, int end)
{
int left = begin, right = end;
int key = left;
while (left < right)
{
//右边先走,找小
while (left < right && a[right] >= a[key])//left < right条件是防止越界
{
right--;
}
//左边再走,找大
while (left < right && a[left] <= a[key])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[key]);
key = left;
return key;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
if ((end - begin + 1) < 15)
{
//优化方法:小区间用直接插入替代,减少递归调用次数
InsertSort(a + begin, end - begin + 1);
}
else
{
int key = PartSort1(a, begin, end);
//[begin,key-1] key [key+1 , end] 三段位置
QuickSort(a, begin, key - 1);
QuickSort(a, key + 1, end);
}
}
动图演示:
思路:(1)把数组 left 位置的数据赋值给 key ,形成了第一个坑位 hole 就是 left 位置,要保存 key 位置的值。
(2)right 先走,找到比 key 位置数据小的值,就停下,将此处的数据放到坑位 hole 中,此时right 位置就形成了新的坑位。
(3)然后 left 再走,找到比 key 位置数据大的值,就停下,将此处的数据放到坑位 hole 中,此时,left 位置就形成新的坑位。
(4)当 left 和 right 相遇时,将 key 位置的数据放入到坑位中,此时,key 数据就放到了正确的位置。
//挖坑法
int PartSort2(int* a, int begin, int end)
{
int left = begin, right = end;
int key = left;
int hole = left;
while (left < right)
{
//右边找小,填到左边的坑里面
if (left < right && a[right] >= a[key])
{
right--;
}
a[hole] = a[right];
hole = right;
//左边找大,填到右边的坑里面
if (left < right && a[left] <= a[key])
{
left++;
}
a[hole] = a[left];
hole = left;
}
a[hole] = a[key];
return hole;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
if ((end - begin + 1) < 15)
{
//优化方法:小区间用直接插入替代,减少递归调用次数
InsertSort(a + begin, end - begin + 1);
}
else
{
int key = PartSort2(a, begin, end);
//[begin,key-1] key [key+1 , end] 三段位置
QuickSort(a, begin, key - 1);
QuickSort(a, key + 1, end);
}
}
动图演示:
思路:(1)首先假设 key 是数组最开始位置,然后用前后指针法,prev 指向第一个元素,cur 指向第二个元素。
(2)cur 先移动,找到比 key 位置数据小的停下。
(3)++prev,交换 prev 与 cur 位置的数据。
(4)当 cur 指向数组最后一个位置的下一个位置时,循环停止。
(5)交换 key 下标与 prev 下标的数据。
//前后指针法
int PartSort3(int* a, int begin, int end)
{
int prev = begin;
int cur = begin + 1;
int key = begin;
while (cur <= end)
{
//找到比key小的值时,跟++prev位置交换,小的往前翻,大的往后翻
while (a[cur] < a[key] && ++prev != cur)
{
//满足条件,进行交换
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[key], &a[prev]);
key = prev;
return key;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
if ((end - begin + 1) < 15)
{
//优化方法:小区间用直接插入替代,减少递归调用次数
InsertSort(a + begin, end - begin + 1);
}
else
{
int key = PartSort3(a, begin, end);
//[begin,key-1] key [key+1 , end] 三段位置
QuickSort(a, begin, key - 1);
QuickSort(a, key + 1, end);
}
}
思路:通过非递归的方式实现的话,我们要借助栈的内存结构让先入的后出,所以要先进 begin 再进 end,出的顺序就是先出右再出左再先排右边再排左边。
//非递归版本
void QuickSortNonR(int* a, int begin, int end)
{
//借助栈实现非递归
ST st;
StackInit(&st);
StackPush(&st, begin);
StackPush(&st, end);
while (!StackEmpty(&st))
{
int right = StackTop(&st);
StackPop(&st);
int left = StackTop(&st);
StackPop(&st);
int key = PartSort1(a, left, right);
//[left,key-1] key [key+1,right]
if (key + 1 < right)
{
StackPush(&st, key + 1);
StackPush(&st, right);
}
if (left < key - 1)
{
StackPush(&st, left);
StackPush(&st, key - 1);
}
}
StackDestory(&st);
}
三数取中是一种优化算法,为了防止 key 位置的数据是该数组中的最小值,进行一趟快速排序后,没有什么变化,我们采用的三数取中的方法,在一个数组中选取一个中间值作为 key ,来进行快速排序,这样的效率会大大的提升。
int GetMidIndex(int* a, int begin, int end)
{
int mid = (begin + end) / 2;
if (a[begin] < a[mid])
{
if (a[mid] < a[end])
{
return mid;
}
else if (a[begin] > a[end])
{
return begin;
}
else
{
return end;
}
}
else //a[begin] > a[mid]
{
if (a[mid] > a[end])
{
return mid;
}
else if (a[begin] > a[end])
{
return end;
}
else
{
return begin;
}
}
}
快排的思想就是不断地分割小序列,然后再递归实现,它的每一层的递归次数以2倍的次数进行增长。当元素较多时以递归的方法实现是不错的,但是当序列元素较少时,再使用递归就没有必要了,我们可以选择使用其他的排序方法来实现小序列的排序。
void QuickSort1(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
if ((end - begin + 1) < 10)
{
InsertSort(a, (end - begin + 1));
}
int mid = GetMidIndex(a, begin, end);
swep(&a[begin], &a[mid]);
int keyi = PartSort3(a, begin, end);
QuickSort1(a, begin, keyi - 1);
QuickSort1(a, keyi+1, end);
}
动图演示:
归并的思想:
归并排序是建立在 归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。
将已有序的子序列合并,得到完全有序的序列;
即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
//归并排序 时间复杂度:O(N*logN) 空间复杂度:O(N)
void _MergeSort(int* a, int begin, int end, int* tmp)
{
if (begin >= end)
{
return;
}
int mid = (begin + end) / 2;
//[begin,mid] [mid+1,end] 递归让子区间有序
_MergeSort(a, begin, mid, tmp);
_MergeSort(a, mid + 1, end, tmp);
//归并
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int i = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[i++] = a[begin1++];
}
else
{
tmp[i++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = a[begin2++];
}
memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
exit(-1);
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
tmp = NULL;
}
我们就控制每个区间就可以归并了,因为归并是二分。
rangeN 表示:每组归并的数据个数。
//非递归归并排序
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
exit(-1);
}
//归并每组数据个数,从1开始,因为1个认为是有序的,可以直接归并
int rangeN = 1;
while (rangeN < n)
{
for (int i = 0; i < n; i += rangeN * 2)
{
//[begin1,end1] [begin2,end2] 归并
int begin1 = i, end1 = i + rangeN - 1;
int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
int j = i;
//end1 begin2 end2越界
if (end1 >= n)
{
break;
}
else if (begin2 >= n)//begin2 end2 越界
{
break;
}
else if (end2 >= n)//end2 越界
{
//修正区间
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
//归并一部分,拷贝一部分
memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
rangeN *= 2;
}
free(tmp);
tmp = NULL;
}
注意:写代码时,需要严密的控制区间,要不然会发生溢出,导致程序崩溃。
有以下三种情况:(1)end1越界,begin2越界,end2越界;(2)begin2越界,end2越界;(3)end2越界
计数排序的核心思想:其实就是映射,将待排序的数据通过映射,放到辅助空间相对应的位置,然后通过统计出现的次数,最后再放回原先的数组。
//计数排序
void CountSort(int* a, int n)
{
assert(a);
int min = a[0];
int max = a[0];
for (int i = 1; i < n; ++i)
{
//求最大值和最小值
if (a[i] < min)
min = a[i];
if (a[i] > max)
max = a[i];
}
int range = max - min + 1;
int* countArr = (int*)malloc(sizeof(int) * range);
memset(countArr, 0, sizeof(int) * range);
//统计次数
for (int i = 0; i < n; ++i)
{
countArr[a[i] - min]++;
}
//排序
int index = 0;
for (int j = 0; j < range; ++j)
{
while (countArr[j]--)
{
//相对位置
a[index++] = j + min;
}
}
free(countArr);
}
排序方法 | 时间复杂度 | 空间复杂度 | 稳定性 |
冒泡排序 | 稳定 | ||
选择排序 | 不稳定 | ||
插入排序 | 稳定 | ||
希尔排序 | 不稳定 | ||
堆排序 | 不稳定 | ||
归并排序 | 稳定 | ||
快速排序 | 不稳定 | ||
计数排序 | 不稳定 |
本文要是有不足的地方,欢迎大家在下面评论,我会在第一时间更正。