一、排序的概念及其应用
1.1排序的概念
1.2排序的应用
生活中有很多地方都能使用到排序算法，像在京东、淘宝等网站搜索商品时，可以按照你的需求给商品进行排序。
1.3 常见的排序算法
以上便是常见的排序算法，下面我们来一一实现他们。
二、常见排序算法的实现
2.1 直接插入排序
直接插入排序的基本思想:
插入排序动图理解:
这里引用一下网上的动图，可以方便大家更好的理解直接插入排序。
代码:
// 插入排序
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)//i要小于n-1是为了防止下面的end+1越界
{
int end = i;
int temp = a[end + 1];//待排序元素
while (end >= 0)
{
if (temp < a[end])//如果temp<a[end],则a[end]向右移动一位
{
a[end + 1] = a[end];
end--;//继续判断前面的元素
}
else
{
break;
}
}
//1.如果走到else跳出循环,此时end大于0时插入的位置是a[end+1]
//2.如果是end<0跳出的循环,此时插入的位置为a[0]
a[end + 1] = temp;//结束后将temp插入到[end+1]位置
}
}
结果:
2.2 希尔排序
希尔排序的基本思想:
先选定一个整数gap，把待排序文件中所有记录分成gap个组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序，然后将gap按一定方式减小，重复上述分组和排序的工作，当gap等于1时，所有记录在统一组内排好序。
因为当gap等于1时，便是直接插入排序，所以希尔排序其实是直接插入排序的改进。
希尔排序静态图理解:
希尔排序比较难理解，当gap不为1时，进行的便是预排序，使这个序列变得更加有序，最后进行直接插入排序时消耗就会降低。
代码:
// 希尔排序
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;//设定的gap减小的方式，+1是为了确保gap最后一定会为1
for (int i = 0; i < n - gap; i++)//与直接插入排序相差无几
{
int end = i;
int temp = a[end + gap];
while (end >= 0)
{
if (temp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = temp;
}
}
}结果:
2.3选择排序
选择排序基本思想:
选择排序动图理解:
选择排序一次排序选择的是最小的或者最大的元素，我们可以对此进行改进，一次排序选出一个最大的和最小的。
代码:
// 选择排序
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)//begin等于end时结束
{
int mini = begin;
int maxi = begin;
for (int i = begin + 1; i <= end; i++)
{
if (a[i] > a[maxi])//找最大的下标
{
maxi = i;
}
if (a[i] < a[mini])//找最小的下标
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
begin++;//begin往后移
end--;//end往前移
}
}这里需要注意的是，如果begin和maxi相等，即maxi在起始位置时，要将mini的值赋给maxi，不然的话，最小值将会被交换到末尾。
如上图所示，如果不修改maxi的值，那么最小值将被换到末尾，整个排序就会出错。
结果:
2.4 堆排序
堆排序基本思想:
// 堆排序
void AdjustDwon(int* a, int n, int root)
{
int child = root * 2 + 1;
while (child < n)
{
if (child + 1 < n && a[child + 1] > a[child])
{
child++;
}
if (a[child] > a[root])
{
Swap(&a[child], &a[root]);
root = child;
child = root * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int n)
{
int end = n - 1;
for (int i = (end - 1) / 2; i >= 0; i--)
{
AdjustDwon(a, n, i);
}
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDwon(a, end, 0);
end--;
}
}结果:
2.5 冒泡排序
冒泡排序基本思想:
冒泡排序就是两两比较，如果后一个比前一个大，就交换他们两个，一趟排序下来可以将最大的元素排在末尾。
冒泡排序动图理解:
代码:
//冒泡排序
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n - 1 - i; j++)
{
if (a[j] > a[j + 1])
{
Swap(&a[j], &a[j + 1]);
}
}
}
}结果:
2.6 快速排序
快速排序基本思想:
任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都拍列在相应位置上为止。
2.6.1 hoare版本
hoare版本动图理解:
right往左走找比key小的值，找到后停下，然后left往右走，找比key大的值，找到后也停下，交换left和right的值，重复上述过程，直到left和right相遇，当left和right相遇时，将key与该位置的值交换。
代码:
// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
int keyi = left;
int begin = right;
int end = left;
while (end<begin)
{
while (end < begin && a[begin] >= a[keyi])
{
begin--;
}
while (end < begin && a[end] <= a[keyi])
{
end++;
}
Swap(&a[end], &a[begin]);
}
Swap(&a[keyi], &a[end]);
return end;
}
//hoare版本
void QuickSort1(int* a, int left, int right)
{
if (left >= right)
{
return;
}
int keyi=PartSort1(a, left, right);
QuickSort1(a, left, keyi - 1);
QuickSort1(a, keyi + 1, right);
}结果:
2.6.2 挖坑法
挖坑法动图理解:
先将第一个值存放到key中，坑位为第一个值的下标，right向右走找比key小的值，找到后将该值填到坑位中，该位置成为新的坑位，left向右走，找比key大的值，找到后也将该值填入到坑位中，该位置成为新的坑位，重复上述过程，直到left和right相遇，将key放入到坑位中。因为left和right必有一个是坑位，一开始坑位在左且先将小的数填到坑位中，所以结束时坑位左边的值都比坑位的值小，右边的值都比坑位的值大。
代码:
// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
int key = a[left];
int kengwei = left;
int begin = right;
int end = left;
while (end < begin)
{
while (end<begin && a[begin]>=key)
{
begin--;
}
a[kengwei] = a[begin];
kengwei = begin;
while (end < begin && a[end] <= key)
{
end++;
}
a[kengwei] = a[end];
kengwei = end;
}
a[kengwei] = key;
return kengwei;
}
//挖坑法
void QuickSort2(int* a, int left, int right)
{
if (left >= right)
{
return;
}
int keyi = PartSort2(a, left, right);
QuickSort2(a, left, keyi - 1);
QuickSort2(a, keyi + 1, right);
}结果:
2.6.3 前后指针法
前后指针法动图理解:
prev指向首元素，cur指向prev的后一个元素，设key为首元素，如果cur指向的元素大于key，则cur独自向右走，否则prev先向右走一步，交换prev和cur的值，再让cur往右走一步，当cur越界时，说明找不到比key小的了，这时交换prev和key的值，这样结束时，key左边的值都比key小，右边的值都比key大。
代码:
// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
int prev = left;
int cur = prev + 1;
int keyi = left;
while (cur < (right - left))
{
if (a[cur] > a[keyi])
{
cur++;
}
else
{
prev++;
Swap(&a[prev], &a[cur]);
cur++;
}
}
Swap(&a[keyi], &a[prev]);
return prev;
}
//前后指针法
void QuickSort3(int* a, int left, int right)
{
if (left >= right)
{
return;
}
int keyi = PartSort3(a, left, right);
QuickSort3(a, left, keyi - 1);
QuickSort3(a, keyi + 1, right);
}结果:
2.6.4 快速排序非递归方法
快速排序非递归方法其实思想上和递归方法差不多，非递归方法是通过利用栈来模拟实现递归，先将初始区间入栈，获取栈顶元素作为区间再出栈，出栈的同时也将他的子区间入栈，重复上述方法直到栈为空，快速排序的非递归方法就是通过栈来模拟实现递归。
代码:
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
Stack sk;
StackInit(&sk);
StackPush(&sk, left);
StackPush(&sk, right);
while (!StackEmpty(&sk))
{
int begin = StackTop(&sk);
StackPop(&sk);
int end = StackTop(&sk);
StackPop(&sk);
int keyi=PartSort1(a, end, begin);
if (end < keyi - 1)
{
StackPush(&sk, left);
StackPush(&sk, keyi - 1);
}
if (begin > keyi + 1)
{
StackPush(&sk, keyi + 1);
StackPush(&sk, right);
}
}
}结果: 
2.7 归并排序
归并排序基本思想:
归并排序步骤:
归并排序的前提是两个子序列必须是有序的，所以我们将子序列不断分解，直至分解到只剩一个数字时，因为只有一个数字时我们可以认为他是有序的，然后再向上两两进行比较。
归并排序动图理解:
归并排序的实现需要创建一个新的数组，将一个序列分为左右两个子序列，当这两个子序列都有序时，便可以进行比较，两个子序列一一进行比较，哪个值小就插入到新开辟的数组中，直到一个序列越界，最后再将没插入完的序列剩下的元素一一插入即可，因为两个序列都是有序地。完成这一步后，我们只需将新开辟的数组中的数据拷回原数组就行了。
代码:
void _MergeSort(int* a, int* temp, int begin, int end)
{
if (begin >= end)
{
return;
}
int mid = (begin + end) / 2;
_MergeSort(a, temp, begin, mid);//左子序列有序
_MergeSort(a, temp, mid + 1, end);//右子序列有序
int begin1 = begin;
int end1 = mid;
int begin2 = mid + 1;
int end2 = end;
int i = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
temp[i++] = a[begin1++];
}
else
{
temp[i++] = a[begin2++];
}
}
//不知道哪个序列结束，将有剩余的序列中的元素进行拷贝
while (begin1 <= end1)
{
temp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
temp[i++] = a[begin2++];
}
//每次归并都将数据拷回原数组，加begin是为了确保下标相同
memcpy(a + begin, temp + begin, sizeof(int) * (end - begin + 1));
}
// 归并排序递归实现
void MergeSort(int* a, int n)
{
int* temp = (int*)malloc(sizeof(int) * n);
if (temp == NULL)
{
perror("malloc fail");
return;
}
_MergeSort(a, temp, 0, n - 1);
free(temp);
temp = NULL;
}结果:
2.7.1 归并排序非递归方法
归并排序的非递归方法与递归方法不同，非递归方法是先一个元素一组，再两个元素一组，四个元素一组，以此类推，直到将所有元素归并完。与递归方法相比少了分的过程。
代码:
// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
int* temp = (int*)malloc(sizeof(int) * n);
if (temp == NULL)
{
perror("malloc fail");
return;
}
int gap = 1;
while (gap < n)//gap为n时只有一个序列，所以gap小于n
{
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i;
int end1 = i + gap - 1;
int begin2 = i + gap;
int end2 = i + 2 * gap - 1;
if (begin2 >= n)//判断是否越界，如果begin2越界，
//那么end2也一定越界，这组数据便可以不用归并了
{
break;
}
if (end2 >= n)//如果只是end2越界，只需修改end2的值为n-1即可
{
end2 = n - 1;
}
int j = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
temp[j++] = a[begin1++];
}
else
{
temp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
temp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
temp[j++] = a[begin2++];
}
memcpy(a + i, temp + i, sizeof(int) * (end2 - i + 1));
}
gap *= 2;//gap每次增大两倍
}
free(temp);
temp = NULL;
}结果: 
2.8 计数排序
计数排序基本思想:
代码:
// 计数排序
void CountSort(int* a, int n)
{
int max = a[0];
int min = a[0];
int i = 0;
for (i = 0; i < n; i++)//找出数组中的最大值和最小值
{
if (a[i] < min)
{
min = a[i];
}
if (a[i] > max)
{
max = a[i];
}
}
int gap = max - min + 1;//计算有几个元素需要计数
int* count = (int*)calloc(gap, sizeof(int));//创建一个新数组并全部初始化为0
for (int i = 0; i < n; i++)
{
count[a[i] - min]++;
}
int j = 0;
for (i = 0; i < gap; i++)
{
while (count[i]--)
{
a[j++] = i + min;
}
}
free(count);
count = NULL;
}
结果:
三、排序算法时间复杂度及稳定性分析
什么是稳定性呢？ 稳定性其实指的并不是说排序的时间复杂度在不同的情况下不会发生改变，稳定性指的是:在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
四、总结
以上就是八大排序算法的原理以及实现，希望上面所讲能够对大家有所帮助，如有错误，感谢指正，如果觉得有帮助的话，点个赞再走吧，感谢各位。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
