排序算法
基础排序
冒泡排序
核心为交换，通过不断进行交换，将大的元素一点一点往后移，每一轮最大的元素排到对应的位置上，形成有序。
设数组长度为N，过程为:
- 共进行N轮排序
- 每一轮排序从数组的最左边开始，两两元素进行比较，左边元素大于右边元素，就交换两个元素的位置，否则不变。
- 每轮排序都会将剩余元素中最大的一个推到最右边，下次排序就不再考虑对应位置的元素。
注意交换不能直接进行，需要中间元素。
实际上排序不需要N轮，N-1轮即可，最后一轮只有一个元素未排序。
// 冒泡排序
void BubbleSort(int arr[], int size)
{
for(int i = 0; i < size-1 ;++i) // 减1是不考虑最后一次交换
{
for(int j = 0 ; j < size - i - 1; ++j )
{
if(arr[j] > arr[j+1])
{
int tmp = arr[j]; // 加入中间元素tmp进行交换
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
int main()
{
int size = 7;
int arr1[] = {2,4,1,7,4,9,3};
BubbleSort(arr1, size);
for(int i = 0 ; i < size;++i)
{
printf("%d ", arr1[i]);
}
}
优化：如果整轮排序中没有出现任何交换，则说明数组是有序的，内层循环中加入标记
没有发生任何交换，则flag一定是1，数组有序
// 改进：没有出现交换则已经有序
void BubbleSort1(int arr[], int size)
{
for(int i = 0 ; i < size - 1; ++i)
{
_Bool flag = 1; // 加入标记
for(int j = 0 ; j < size - 1 - i; ++j)
{
int tmp =arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
if(flag)
{
break;
}
}
}
排序稳定性，大小相同的两个元素在排序前和排序后的先后顺序不变，则排序算法就是稳定的。比如以上的冒泡排序法只会在前者大于后者的情况下才会发生交换，不会影响到相等的两个元素。
插入排序
类似于斗地主的插牌。默认一开始只有第一张牌是有序的，剩余部分进行遍历，然后插到前面对应的位置上。
设数组长度为N
- 一共进行N轮排序
- 每轮排序会从后面依次选择一个元素，与前面已经处于有序的元素，从后往前比较，直到遇到一个不大于当前元素的元素，将当前元素插入到此元素的前面。
- 插入元素后，后续元素则全部后移一位。
- 当后面所有元素全部遍历完成，全部插入到对应位置之后结束排序。
// 插入排序
void InsertSort(int arr[], int size)
{
for(int i = 1; i < size -1; ++i) // 从第2个元素开始
{
int tmp = arr[i], j = i;
while (j > 0 && arr[j-1] > tmp) // 只要j>0并且前一个元素大于当前元素
{
arr[j] = arr[j-1]; // 交换前一个元素
j--;
}
arr[j] = tmp;
}
}
int main()
{
int arr1[] = {2,1,8,5,6,4};
InsertSort(arr1, 6);
printArray(arr1, 6);
}
改进：寻找插入位置上逐个比较，花费时间长，如果前面一部分元素已经是有序状态，可以考虑使用二分搜索算法来查找对应的插入位置，节省插入点的时间。
// 二分搜索法
int BinarySearch(int arr[], int left, int right, int target)
{
int mid;
while(left <= right)
{
mid = (left + right) / 2;
if(target == arr[mid])
{
return mid + 1;
}
else if (target < arr[mid])
{
right = mid - 1; // 目标值小于中间的值，往左边去找
}
else
{
left = mid + 1; // 往右边去找
}
}
return left; // 二分划分范围，left就是插入的位置
}
// 改进的插入排序
void InsertSort1(int arr[], int size)
{
for(int i = 0 ; i < size; ++i)
{
int tmp = arr[i];
int j = BinarySearch(arr,0,size-1,arr[i]); // 二分搜索查找插入的位置
for( int k = i ; k > j; k--)
{
arr[k] = arr[k-1]; // 往后移
}
arr[j] = tmp;
}
}
算法稳定性，在优化前的插入排序，实际上是不断向前寻找一个不大于待插入元素的元素，相等时只会插入到其后面，不会修改相等元素的顺序；而改进后的二分搜索法，可能会将两个连续相等元素分割开来。
选择排序
每次都去后面找一个最小的放到前面。
设数组长度为N
- 共进行N轮排序
- 每轮排序会从后面的所有元素中寻找一个最小的元素，与已经排序好的下一个位置进行互换
- 进行N轮交换后，得到有序数组
// 选择排序
void SelectSort(int arr[], int size)
{
for(int i = 0 ; i < size - 1; ++i) // N-1轮排序
{
int min = i ; // 记录当前最小的元素，默认是剩余元素中的第一个
for(int j = i + 1; j < size;++j)
{
if(arr[min] > arr[j])
{
min = j;
}
int tmp = arr[i]; // 找出最小元素之后，开始交换
arr[i] = arr[min];
arr[min] = tmp;
}
}
}
// 打印
void printArray(int arr[],int size)
{
for(int i = 0 ; i < size;++i)
{
printf("%d ", arr[i]);
}
}
int main()
{
int arr1[] = {2,9,6,8,3,6,5};
SelectSort(arr1 , 7);
printArray(arr1, 7);
}
改进：因为每次需要选一个最小的，不妨顺便选个最大的，小的往左边丢，大的往右边丢。
// 交换
void swap(int* a, int*b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
// 优化的选择排序
void SelectSort1(int arr[], int size)
{
int left=0, right = size - 1; // 假设左右排好序，往中间缩小
while (left < right)
{
int max = right, min = left;
for(int i = left; i < right; ++i)
{
// 同时找最大和最小的
if(arr[i] < arr[min])
{
min = i;
}
if(arr[i] > arr[max])
{
max = i;
}
}
swap(&arr[max], &arr[right]); // 先把大的换到右边
// 大的换到右边之后，有可能被换出来的是最小的，需要判断以下
// 如果遍历完最小的是当前右边排序的第一个元素
// 将min换到那个位置
if(min == right)
{
min = max;
}
swap(&arr[min], &arr[left]);
left++;
right--;
}
}
稳定性：由于每次寻找的是最小的元素，向前插入时会发生交换操作，当存在两个连续相等元素，破坏了原有的顺序。不稳定的。
比较三种基础排序
冒泡排序（优化后）
- 最好情况时间复杂度：O(n)，本身是有序的，只需要一次遍历。
- 最坏情况时间复杂度：O(n^2)，倒序。
- 空间复杂度：O(1)，只需要一个变量存储需要交换的变量
- 稳定
插入排序 - 最好情况时间复杂度：O(n)，本身是有序的，插入的位置也是同样的位置，不变动任何元素
- 最坏情况时间复杂度：O(n^2)，倒序。
- 空间复杂度：O(1)，只需要一个变量存储抽出来的元素
- 稳定
选择排序 - 最好情况时间复杂度：O(n^2)，即使数组本身是有序的，每一轮还得将剩余部分依次找完才确定最小的元素
- 最坏情况时间复杂度：O(n^2)
- 空间复杂度：每一轮需要记录最小元素位置，空间复杂度为O(1)
- 不稳定
进阶排序
快速排序
快速排序是冒泡排序的进阶版，由于冒泡排序是对相邻元素进行比较和交换，每次只能移动一个位置，效率相对较低；而快速排序是从两端向中间进行，一轮就可将较小的元素交换到左边，较大的元素交换到右边。
实际上每一轮目的就是将较大的丢到基准右边，较小的丢到基准左边
- 一开始排序为整个数组
- 排序之前，以第一个元素作为基准
- 从最右边向左看，依次将每一个元素与基准元素进行比较，如果该元素比基准元素小，就与左边遍历位置上的元素（一开始为基准元素位置）进行交换，保留右边当前遍历的位置
- 交换后，转为从左边往右开始遍历元素，如果发现比基准元素大，则与之前保留右边遍历的位置上元素进行交换，同样保留左边当前遍历的位置
- 当左右遍历撞到一起，本轮快速排序完成，中间的位置元素就是基准元素
- 以基准位置为中心，划分左右两边，同样方式进行
代码实现
// 快速排序
void QuickSort(int arr[], int start, int end)
{
if(start >= end) // 不满足初始位置则返回
{
return;
}
int left = start, right = end; // 定义两个指向左右两个端点的指针
int pivot = arr[left]; // 预先确定基准点为左端第一个元素
while (left < right)
{
while(left < right && arr[right] >= pivot)
{
right--;// 从右往左看
}
arr[left] = arr[right]; // 比基准值小就放到左边去
while (left < right&& arr[left] <= pivot)
{
left++; // 从左往右看
}
arr[right] = arr[left]; // 比基准值大就放到右边
arr[left] =pivot; //相遇位置即为基准存放的位置
}
QuickSort(arr, start , left-1); //划分基准左边
QuickSort(arr, left+1, end); // 划分基准右边， 再次进行快速排序
}
测试
int main()
{
int arr1[]= {9,3,6,3,4,8,1,2};
QuickSort(arr1, 0 , 8);
for(int i = 0; i < 8 ; ++i)
{
printf("%d ", arr1[i]);
}
}
双轴快速排序
快速排序的升级版，双轴快速排序，可对大数组进行。如果遇到数组完全倒序的情况
每一轮需要完整遍历整个范围，每一轮最大或最小的元素被推向两边，则此完全倒序情况快速排序退化为冒泡排序。为解决这种极端情况，再添加一个基准元素，使得数组可分为三段。
分为三段后，每轮双轴排序结束后对三段继续进行双轴快速排序。该适用于那些量比较大的数组。
首先取出首元素和尾元素作为两个基准，对其进行比较，若基准1大于基准2，先交换两个基准。
需要创建三个指针
从橙色指针所指元素开始进行判断，
- 小于基准1，那需要先将蓝色指针向后移，把元素交换到蓝色指针那去，然后橙色指针也向后移动
- 不小于基准1且不大于基准2，直接把橙色指针向前移动即可
- 大于基准2，需要丢到右边去，先将右边指针左移，不断向前找到一个比基准2小的，进行交换
橙色指针与绿色指针之间即为待排序区域
代码实现：
void swap(int* a, int*b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void dualPivotQuickSort(int arr[], int start, int end)
{
if(start >= end)
{
return; // 结束条件
}
if(arr[start] > arr[end]) // 首尾两个基准比较
{
swap(&arr[start], &arr[end]); // 大的换到后面
}
int pivot1 = arr[start], pivot2 = arr[end]; // 取出两个基准元素
int left = start, right = end, mid = left + 1; // 分三个区域，三个指针
while (mid < right)
{
if(arr[mid] < pivot1) // mid所指向元素小于基准1，需要放到最左边
{
swap(&arr[++left], &arr[mid++]); // 和最左边交换，left 和 mid向前移动
}
else if(arr[mid] <= pivot2) // 不小于基准1但小于基准2，在中间
{
mid++; // 本身在中间，向前移动以缩小范围
}
else // 右边的情况
{
while (arr[--right] > pivot2 && right > mid); // 先移动右边指针，需要右边位置来存放需要换过来的元素
if(mid >= right)
{
break; // 剩余元素找完，没有比基准2小的，可直接结束
}
swap(&arr[mid], &arr[right]); // 还有剩余元素，找到比基准2小的，直接交换
}
}
swap(&arr[left], &arr[start]); // 基准1与left交换，基准1左边元素都比其小
swap(&arr[right],&arr[end]); // 基准2与right交换，基准2右边元素都比其大
// 继续对剩下三个区域双轴快速排序
dualPivotQuickSort(arr, start,left-1);
dualPivotQuickSort(arr, left+1, right-1);
dualPivotQuickSort(arr, right+1, end);
}
dualPivotQuickSort(arr1, 0, 8);
for(int i = 0; i < 8 ; ++i)
{
printf("%d ", arr1[i]);
}
希尔排序（缩小增量排序）
直接插入排序的进阶版，极端情况会出现让所有已排序元素后移的情况（比如刚好要插入的是一个特别小的元素），为解决这种问题，对整个数组按照步长进行分组，优先比较距离较远的元素。
步长是由一个增量序列，当增量序列一般使用
n
2
、
n
4
、
n
8
.
.
.
、
1
\frac{n}{2}、\frac{n}{4}、\frac{n}{8}...、1
2n、4n、8n...、1这样的序列。
设数组长度为N，详细过程为:
- 求出最初步长,n/2
- 整个数组按照步长进行分组，两两一组（n为奇数，第一组有三个元素）
- 分别在分组内插入排序
- 排序后，将步长/2，重新分组，重复上述步骤，直到步长为1，插入排序最后一遍结束
插入排序后，小的元素尽可能地向前走，缩小步长，4/2=2
代码实现
// 希尔排序
void shellSort(int arr[], int size)
{
int delta = size / 2;
while (delta >= 1) // 使用之前的插入排序，此时需要考虑分组
{
for(int i = delta; i < size; ++i) // 从delta开始，前delta个组的第一个元素默认是有序状态
{
int j = i, tmp = arr[i]; // 依然是把待插入的先抽出来
while (j >= delta && arr[j - delta] > tmp)
{
// 需要按步长往回走，所以是j-delta，j必须大于等于delta才可以,j-delta小于0说明前面没有元素
arr[j] = arr[j - delta];
j -= delta;
}
arr[j] = tmp;
}
delta /= 2; // 分组插排结束之后，再计算步长
}
}
int main()
{
int arr[] = {3,5,7,2,9,0,6,1,8,4};
shellSort(arr, 10);
for(int i = 0 ; i < 10; ++i)
{
printf("%d ", arr[i]);
}
}
尽管有循环多次，但时间复杂度比O(n^2)小，小的元素往左靠。希尔排序不稳定，因为按步长分组，有可能相邻得两个相同元素，后者在自己组内被换到前面去。
堆排序
选择排序一种，但能比选择排序更快。
小根堆（小顶堆），对一棵不完全二叉树，树中父亲结点都比孩子结点小；大根堆（大顶堆）树中父亲结点都比孩子节点大。
堆是一棵完全二叉树，数组来表示
构建一个堆，将一个无序的数组依次输入，最后存放的序列是一个按顺序排放的序列。
但仍需要额外O(n)的空间作为堆，可以对其进一步优化，减少空间上的占用。直接对给定的数组进行堆的构建
设数组长度为N
- 将给定数组调整为大顶堆
- 进行N轮选择，每次选择大顶堆顶端元素从数组末尾开始向前存放（交换堆顶和堆的最后一个元素）
- 交换完成后，重新对堆的根节点进行调整，使其继续满足大顶堆的性质
- 当N轮结束后，得到从小到大的数组
1643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
