2022.3.30 归并排序和快速排序

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）  稳定性：稳定