本文详细介绍了八种常见的排序算法，包括直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序（Hoare法、挖坑法和前后指针）、归并排序以及计数排序，探讨了它们的基本思想、时间复杂度、空间复杂度和稳定性。
目录
1.直接插入排序
基本思想：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
可理解为我们平时玩扑克一样，一个一个进行插入到有序数列中。
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性(相同的数经过排序后，他原来的顺序是否发生变化)：稳定
代码实现
思路：首先我们先将后面的数(end)不断与前面的数进行比较，如果end大于前一个数，则end不变放在前一个数的后面，如果end小于前一个数，则需要不断与前面进行比较，然后放到比end小的数的后面。
void Insertsort(int* a, int sz)
{
//把比他小的插入他的后面
//局部有序，直接插入要好。与冒泡对比
for (int i = 0; i < sz; i++)
{
int end = i;
int tmp = a[end + 1];//用tmp保存这个数，防止移动时,最后的数被覆盖
while (end >= 0)//单趟
{
if (a[end] > tmp)
{
a[end+1] = a[end];//后移
}
else
{
break;
}
end--;
}
a[end + 1] = tmp;//保证每次开始时，a[end+1]的是对的
}
}2.希尔排序
基本思想：
先选定一个整数间隔n，然后将每相差n的两个数进行排序，然后将n不断减小，这样这些数不断接近有序，让大的数不断右移，小的数不断左移，最后当n的值为1时，该数列就是有序，这样的排序就是希尔排序。
时间复杂度：O(1.3^N)
空间复杂度：O(1)
稳定性：不稳定（因为每次是交换，可能会把相同的数位置发生变化）
代码实现：
思路：
不断对间隔为n的两个数进行比较，这样就小的左移，大的数右移，然后不断缩小n的值。
void ShellSort(int* a, int n)
{
int gap = n;//间隔为n的gap
while (gap > 1)
{
//gap = gap / 2;
gap = gap / 3 + 1;//gap变小
for (int i = 0; i < n - gap; ++i)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)//单趟
{
if (tmp < a[end])//间隔为n进行比较
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;//与原来的位置进行交换
}
}
}3.直接选择排序
基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定
代码实现：先遍历一遍数组，找出每趟中的最小最大值，放在前面最后的位置。
void swap(int* a1, int* a2)
{
int temp = *a1;
*a1 = *a2;
*a2 = temp;
}
void slectsort(int *a,int sz)//每次选择最大最小的值
{
int end = sz - 1;
int begin = 0;
while (begin < end)
{
int mini = begin;
int maxi = begin;
for (int i = 1; i < sz; i++)//记录每趟最大值最小值
{
if (a[maxi] < a[i])
{
maxi = i;
}
if (a[mini] > a[i])
{
mini = i;
}
}
swap(&a[begin], &a[mini]);//把最小值放在数组的前面
//调整
if (maxi == begin)
{
maxi = mini;//当两个相同时，应该把前面的数与后面的进行交换
}
swap(&a[end], &a[maxi]);//把最大值放在数组的后面
end--;
begin++;
}
}4.堆排序
基本思想：是指利用堆积树（堆）它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆
时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定
代码实现：
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
// 找出小的那个孩子
if (child + 1 < n && a[child + 1] > a[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)
{
// 向下调整建堆
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;
}
}
思路：
5.冒泡排序：
基本思想：每次进行两两比较，大的数不断后移，小的数不断前移。但是该排序的时间复杂度比较大,总共执行n^2次，他的时间复杂度比较大,O(N^2).
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定
代码实现：每次两两进行比较，如果前一个数大于后一个数，那么就进行交换。ps：如果第一次遍历没有进行交换，那么这个数组就是有序的。可直接跳出循环
void BubbleSort(int* a, int n)
{
for (int j = 0; j < n; j++)
{
int exchange = 0;
for (size_t i = 1; i < n-j; i++)
{
if (a[i - 1] > a[i])//前一个数大于后一个数
{
Swap(&a[i - 1], &a[i]);//进行交换
exchange = 1;
}
}
if (exchange == 0)//没有交换就直接跳出循环
{
break;
}
}
}6.快排：
6.1 hoare法
基本思想：定义一个key，left，right变量，right先移动，一直移动，直到找到比key大的交换，相同的将left移动，直到找到比key小的交换，当left与right遇到时，将当前值与key交换，然后一直递归，一直进行下去。
单趟图
三数取中优化：
1. 三数取中法选key
2. 递归到小的子区间时，可以考虑使用插入排序
//三数取中
int GetMidi(int* a, int left, int right)
{
int mid = (left + right) / 2;
// left mid right
if (a[left] < a[mid])
{
if (a[mid] < a[right])
{
return mid;
}
else if (a[left] > a[right]) // mid是最大值
{
return left;
}
else
{
return right;
}
}
else // a[left] > a[mid]
{
if (a[mid] > a[right])
{
return mid;
}
else if (a[left] < a[right]) // mid是最小
{
return left;
}
else
{
return right;
}
}
}
int PartSort1(int* a, int left, int right)
{
int midi = GetMidi(a, left, right);//优化-三数取中
swap(&a[left], &a[midi]);
int keyi = left;
while (left < right)
{
// 右边先走，先找小
while (left < right && a[right] >= a[keyi])
{
--right;
}
// 左边后走，找大
while (left < right && a[left] <= a[keyi])
{
++left;
}
swap(&a[left], &a[right]);
}
swap(&a[keyi], &a[left]);
return left;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)
return;
int keyi = PartSort1(a, begin, end);
// [begin, keyi-1] keyi [keyi+1, end]
//递归
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}6.2挖坑法：
单趟图
int PartSort2(int* a, int left, int right)
{
int midi = GetMidi(a, left, right);
swap(&a[left], &a[midi]);
int key = a[left];
// 保存key值以后，左边形成第一个坑
int hole = left;
while (left < right)
{
// 右边先走，找小，填到左边的坑，右边形成新的坑位
while (left < right && a[right] >= key)
{
--right;
}
a[hole] = a[right];
hole = right;
// 左边再走，找大，填到右边的坑，左边形成新的坑位
while (left < right && a[left] <= key)
{
++left;
}
a[hole] = a[left];
hole = left;
}
a[hole] = key;
return hole;
}
void QuickSort(int* a, int begin, int end)
{
if (begin >= end)
return;
int keyi = PartSort2(a, begin, end);
// [begin, keyi-1] keyi [keyi+1, end]
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}6.3前后指针：
经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。然后也还是将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作
int PartSort3(int* a, int left, int right)
{
int midi = GetMidi(a, left, right);
swap(&a[left], &a[midi]);//避免了用最大的元素或最小的元素作为key进行排序了
int prev = left;
int cur = prev + 1;
int keyi = left;
while (cur <= right)
{
//如果cur小于keyi对应的值，那么就将prev与cur进行交换
if (a[cur] < a[keyi] && ++prev != cur)
{
swap(&a[prev], &a[cur]);
}
++cur;
}
//最后cur跳出循环，将keyi对应的值与prev对应的值交换
swap(&a[prev], &a[keyi]);
return prev;
}
6.4hoare与前后指针结合（处理大量重复数据）：
时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定
代码实现：
1.当cur小于key时，交换cur与left的值，cur++，left++
2.当cur大于key时，交换cur与right的值，right--
3.等于时，则cur++
//针对大量重复数据
void quicksort2(int* a, int left, int right)
{
if (left >= right)
return;
int begin = left;
int end = right;
int midi = GetMidi(a, left, right);
swap(&a[left], &a[midi]);
int cur = left + 1;
int key = a[left];
//三路划分
while (cur <= right)
{
if (key > a[cur])
{
swap(&a[left], &a[cur]);
cur++;
left++;
}
if (key < a[cur])
{
swap(&a[cur], &a[right]);
right--;
}
else
cur++;
}
//划分区间,经过一次排序后形成三个区间
//[begin,left-1],[left,right],[right+1,end]
quicksort2(a, begin, left - 1);
quicksort2(a, left, right);
quicksort2(a, right + 1, end);
}7.归并排序：
基本思想：归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
时间复杂度：O(logN*N)
空间复杂度：O(N)
稳定性：稳定
代码实现：每次不断归并，再将每个元素进行排序，拷贝到新数组tmp中。
void _MergeSort(int* a, int* tmp, int begin, int end)
{
if (end <= begin)
return;
//取中
int mid = (end + begin) / 2;
// [begin, mid][mid+1, end]
//不断取办
_MergeSort(a, tmp, begin, mid);
_MergeSort(a, tmp, mid+1, end);
// 归并到tmp数据组，再拷贝回去
// a->[begin, mid][mid+1, end]->tmp
int begin1 = begin, end1 = mid;
int begin2 = mid+1, end2 = end;
int index = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
//后面不断拷贝
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 拷贝回原数组
memcpy(a + begin, tmp + begin, (end - begin + 1)*sizeof(int));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
_MergeSort(a, tmp, 0, n - 1);
free(tmp);
}
8.计数排序(非比较排序)：
基本思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。建立一个数组，下标用需要比较的数组的值表示，记录相同元素出现的次数。
时间复杂度：O(N + range)
空间复杂度：O(range)
稳定性:稳定
局限性：选用的数据必须相对集中，因为要开辟多少数组的空间。
代码实现：将数组中的每一个数作为新数组的下标，每出现一次，则将这个这个值对应下标的值加一，依次进行，最后将这个数组按顺序进行排序(因为新数组的大小就是原数组每个下标出现的次数)
void CountSort(int* a, int n)
{
int min = a[0], max = a[0];
for (size_t i = 0; i < n; i++)//找出最大值最小值
{
if (a[i] < min)
min = a[i];
if (a[i] > max)
max = a[i];
}
int range = max - min + 1;//得到所要开辟的空间大小。
int* count = (int*)malloc(sizeof(int) * range);
printf("range:%d\n", range);
if (count == NULL)
{
perror("malloc fail");
return;
}
memset(count, 0, sizeof(int) * range);
// 统计数据出现次数
for (int i = 0; i < n; i++)
{
count[a[i] - min]++;
}
// 排序
int j = 0;
for (int i = 0; i < range; i++)遍历完新数组
{
while (count[i]--)//每次--
{
a[j++] = i + min;
}
}
}
扫一扫
794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
