目录
一、排序的概念
1、相关概念
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的，否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内存之间移动数据的排序。
2、常见的排序算法
插入排序：直接插入排序、希尔排序
选择排序：选择排序、堆排序
交换排序：冒泡排序、快速排序
归并排序：归并排序
二、常见排序算法的实现
1、相关头文件
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
//插入排序
void InsertSort(int* a , int n);
//打印数组
void PrintArray(int* a , int n);
//希尔排序
void ShellSort(int* a , int n);
//冒泡排序
void BubbleSort(int* a, int n);
//选择排序
void SelectSort(int* a, int n);
//快速排序
void QuickSort(int* a , int begin , int end);
//快速排序非递归
void QuickSortNoR(int* a, int begin, int end);
//归并排序
void MergeSort(int* a, int n);
//归并排序非递归
void MergeSortNoR(int* a, int n);2、插入排序
基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列 。
void InsertSort(int* a , int n)
{
for (int i = 0; i < n - 1; i++)
{
int end = i;
int tmp = a[i + 1];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + 1] = a[end];
--end;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}直接插入排序特性总结
·元素集合越接近有序，直接插入排序算法的时间效率越高
·时间复杂度：O(n^2)
·空间复杂度：O(1)
·稳定性：稳定
3、堆排序
//向下调整
void AdjustDowm(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);
}
int end = n - 1;
while(end > 0)
{
swap(&a[0] , &a[end]);
AdjustDown(a , end , 0);
end--;
}
}堆排序特性总结
·时间复杂度：O(nlogn)
·空间复杂度：O(1)
·稳定性：不稳定
4、希尔排序
希尔排序又称缩小增量法。希尔排序的基本思想是：先选定一个整数，把排序文件中的所有记录分成n个组，所有距离为这个选定的整数的记录分在同一组，并对每一组内的记录进行排序。然后缩小这个整数，重复上述分组和排序的工作。当这个整数到达1时，所有记录在同一组内排好序。
void ShellSort(int* a , int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
for (int i = 0; i < n - gap; i += gap)//每组排序
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}希尔排序的特性总结：
·希尔排序是对直接插入排序的优化
·当gap>1时都是预排序，目的是让数组更接近有序。当gap==1时，数组已经接近有序了，这样就会很快。这样对整体而言，可以达到优化的效果。
·希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算。
稳定性：不稳定
5、选择排序
基本思想：每一次从待排序的数据元素中选出最小（或是最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
void SelectSort(int* a, int n)
{
int begin = 0, end = n - 1;
int maxi = begin, mini = begin;
while (begin < end)
{
for (int i = begin; i <= end; i++)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);
//如果maxi和gegin重叠
if (maxi == begin)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
}直接选择排序的特性总结：
·直接选择排序的思想很好理解，但是效率不是很好。实际中很少用
·时间复杂度：O(n^2)
·空间复杂度：O(1)
·稳定性：不稳定
6、冒泡排序
基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
void BubbleSort(int* a, int n)
{
for (int j = 0; j < n; j++)
{
bool exchange = false;
for (int i = 1; i < n - j; i++)
{
if (a[i - 1] > a[i])
{
int tmp = a[i];
a[i] = a[i - 1];
a[i - 1] = tmp;
exchange = true;
}
}
if (exchange == false)
{
break;
}
}
}冒泡排序的特性总结：
·时间复杂度：O(N^2)
·空间复杂度：O(1)
·稳定性：稳定
7、快速排序
快速排序是hoare于1962年提出的一种二叉树结构的交换排序方法，基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两个序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排在相应的位置为止。
将基准值排到相应的位置有以下三种算法。
（1）hoare版本
设置左右两个指针，从右边开始，右边找小，左边找大，找到了就交换两个值，直到两个指针相遇基准值就是最终位置。其中为了优化算法，基准值取第一个、最后一个和中间的中间值。
int GetMidIndex(int* a, int left, int right)
{
int mid = (left + right) / 2;
if (a[left] < a[mid])
{
if (a[mid] < a[right])
{
return mid;
}
else if (a[left] > a[right])
{
return left;
}
else
{
return right;
}
}
else
{
if (a[mid] > a[right])
{
return mid;
}
else if (a[left] < a[right])
{
return left;
}
else
{
return right;
}
}
}
//hoare
int partSort1(int* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);
Swap(&a[left], &a[mid]);
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 = partSort3(a, begin, end);
QuickSort(a, begin, keyi-1);
QuickSort(a, keyi + 1, end);
}（2）挖坑法
先将第一个数据存放为临时变量key中，形成一个坑位，并记录坑位的数组下标，设置左右两个指针，从右开始找小找到就将该值和坑位的值交换并且把坑位设置成该值的下标，从左开始找大重复上述工作，最后将坑位的设置为最开始的key值。
//挖坑法
int partSort2(int* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);
Swap(&a[left], &a[mid]);
int key = a[left];
int pit = left;
while (left < right)
{
//从右边找找小
while (left < right && a[right] >= key)
{
right--;
}
a[pit] = a[right];
pit = right;
//从左边找找大
while (left < right && a[left] <= key)
{
left++;
}
a[pit] = a[left];
pit = left;
}
a[pit] = key;
return pit;
}（3）前后指针法
初始时，prev指针指向序列开头，cur指针指向prev指针的后一个位置。如果cur的值小于基准值并且cur值不等于prev值，交换cur和prev值cur++直到cur大于右指针。最后交换prev和基准值。
//前后指针
int partSort3(int* a, int left, int right)
{
int mid = GetMidIndex(a, left, right);
Swap(&a[left], &a[mid]);
int keyi = left;
int prev = left, cur = left + 1;
while (cur <= right)
{
if (a[cur] < a[keyi] && a[++prev] != a[cur])
{
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[prev], &a[keyi]);
return prev;
}（4）快速排序非递归版本
以上是快排的递归版本，要实现快排的非递归版本要借助栈。
先实例化一个栈并初始化，将起始和结束两个指针压入栈中，当栈非空时进入循环，right指针取栈顶元素，然后出栈，left指针取栈顶元素，然后出栈，然后进行一趟的基准值排序，将序列划分为三部分left---keyi-1 , keyi , keyi+1---right，如果left小于keyi-1，left和keyi-1进栈，如果keyi+1小于right，keyi+1和right进栈。重复上诉工作直到栈为空。
void QuickSortNoR(int* a, int begin, int end)
{
ST st;
STInit(&st);
STPush(&st, begin);
STPush(&st, end);
while (!STEmpty(&st))
{
int right = STTop(&st);
STPop(&st);
int left = STTop(&st);
STPop(&st);
int keyi = partSort3(a, left, right);
if (left < keyi-1)
{
STPush(&st, left);
STPush(&st, keyi - 1);
}
if (keyi + 1 < right)
{
STPush(&st, keyi+1);
STPush(&st, right);
}
}
STDestroy(&st);
}快速排序特性总结
·快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
·时间复杂度：O(N*logN)
·空间复杂度：O(logN)
·稳定性：不稳定
8、归并排序
归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个典型应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
（1）归并排序递归版本
void _MergeSort(int* a, int begin, int end , int* tmp)
{
if (begin == end)
return;
int mid = (begin + end) / 2;
_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));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
_MergeSort(a, 0, n - 1 , tmp);
free(tmp);
}（2）归并排序非递归版本
void MergeSortNoR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
int gap = 1;
while (gap < n)
{
int j = 0;
for (int i = 0; i < n; i += gap * 2)
{
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + gap * 2 - 1;
if (end1 >= n)
{
end1 = n - 1;
//修成不存在的区间
begin2 = n;
end2 = n - 1;
}
else if (begin2 >= n)
{
begin2 = n;
end2 = n - 1;
}
else if (end2 >= n)
{
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, tmp, sizeof(int) * n);
gap *= 2;
}
free(tmp);
}注：非递归版本在归并时可能出现，end1、begin2、end2越界的情况要注意修正区间。
归并排序特性总结
·归并排序的缺点在于需要O(N)的空间复杂度，归并排序的思想更多的是解决在磁盘中的外排序问题。
·时间复杂度：O(N*logN)
·空间复杂度：O(N)
·稳定性：稳定
1143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
