1. 归并排序
归并排序也叫二路归并排序,将所有数据单独给每个数据每个组(每个数据单独看,就是有序的),其实也就是将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。这个概念还是有点难理解,可以根据下面这个图来详细了解:
代码:
#include<stdio.h>
#include<stdlib.h>
void Merge(int arr[], int len, int gap)
{
int low1 = 0;
int high1 = low1+gap-1;
int low2 = high1+1;
int high2 = low2+gap-1<len ? low2+gap-1 : len-1;
int *brr = (int*)malloc(len * sizeof(int));
assert(brr != NULL);
int i=0;//i指向辅助空间brr的下标
while(low2 < len)//写法不唯一:目的就一个,证明两个手抓到的两个组都有数据
{
while(low1<=high1 && low2<=high2)//保证两个组内还有数据去拿来比较
{
if(arr[low1] <= arr[low2])
{
brr[i++] = arr[low1++];
}
else
{
brr[i++] = arr[low2++];
}
}
//此时,肯定有一个手抓的组为空了,需要判断一下哪个手,做对应的出来
while(low1 <= high1)//左手没空,此时将左手数据向brr中挪动
{
brr[i++] = arr[low1++];
}
while(low2 <= high2)//右手没空,此时将右手数据向brr中挪动
{
brr[i++] = arr[low2++];
}
//此时应该,继续向后抓两个组
low1 = high2+1;
high1 = low1+gap-1;
low2 = high1+1;
high2 = low2+gap-1<len ? low2+gap-1: len-1;
}
//此时,最外层while退出,有两种可能性:1.左手有数据,右手空了 2.左右手都空了
while(low1 < len)//左手没空,此时将左手数据向brr中挪动 //不要写成low1<=high1 因为这里没有办法保证high1的合法性
{
brr[i++] = arr[low1++];
}
//最后将brr中的数据全部重新覆盖到arr里,即可
for(int i=0; i<len; i++)
{
arr[i] = brr[i];
}
free(brr);
}
//归并排序 时间复杂度O(nlogn) 空间复杂度O(n) 稳定性:稳定
void MergeSort(int *arr, int len)
{
for(int i=1; i<len; i*=2)// O(logn)
{
Merge(arr, len, i);
}
}
int main()
{
int arr[] = {84,9,18,19,48,12,90,84,8,12};
MergeSort(arr, sizeof(arr)/sizeof(arr[0]));
Show(arr, sizeof(arr)/sizeof(arr[0]));
return 0;
}
2. 快速排序
根据如下的步骤,可以了解快排的思想
代码:
//一次划分函数 核心函数 //返回基准值最终所在下标
int Partition(int *arr, int left, int right)
{
//先讲arr数组里的[left, right]的第一个值 作为基准值
int tmp = arr[left];
if(left < right)
{
while(left<right && arr[right] > tmp)//左右边界没有相遇且当前右边的值大于基准值tmp
right--;
if(left < right)//如果此时,左右边界没有相遇,那就只能证明右边right找到了一个小于等于基准值tmp的值
{
arr[left] = arr[right];
}
else
{
break;
}
while(left<right && arr[left] <= tmp)//左右边界没有相遇且当前左边的值小于等于基准值tmp
left++;
if(left < right)//如果此时,左右边界没有相遇,那就只能证明左边left找到了一个大于基准值tmp的值
{
arr[right] = arr[left];
}
else
{
break;
}
}
arr[left] = tmp;//此时 因为 left == right
return left;//return right ok
}
void Quick(int *arr, int left, int right)
{
if(left < right)//通过left <right 保证[left, right]这个范围内至少两个数据
{
int par = Partition(arr, left, right);
if(left < par-1)//基准值左半部分 至少有两个值才有必要去递归
{
Quick(arr, left, par-1);
}
if(par+1 < right)//基准值右半部分 至少有两个值才有必要去递归
{
Quick(arr, par+1, right);
}
}
}
//快速排序:时间复杂度O(nlogn) 空间复杂度O(1) 稳定性:不稳定
void QuickSort(int *arr, int len)
{
Quick(arr, 0, len-1);
}
int main()
{
int arr[] = {84,9,18,19,48,12,90,84,8,12};
QuickSort(arr, sizeof(arr)/sizeof(arr[0]));
Show(arr, sizeof(arr)/sizeof(arr[0]));
return 0;
注意:注释在每一个语句之后
快速排序:时间复杂度O(nlogn) 空间复杂度O(1) 稳定性:不稳定
归并排序:时间复杂度O(nlogn) 空间复杂度O(n) 稳定性:稳定