数据结构----归并排序、快速排序

一、归并排序

1、规则

首先将所有的数据默认每个组，当所有的数
1、将所有数据单独给每个数据每个组（每个数据单独看，就是有序的）



两两合并指的是两个组合并。

2、代码及结果

//一次融合函数  时间复杂度O（n）  空间复杂度O（n）
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[] = { 12,2,39,88,4,6,25,232,62,221 };
	MergeSort(arr, sizeof(arr)/sizeof(arr[0]));
	Show(arr, sizeof(arr)/sizeof(arr[0]));
	return 0;
}

结果：

3、时间复杂度、空间复杂度、稳定性

• 时间复杂度：O(n*logn)
• 空间复杂度：O(n)
• 稳定性：稳定

二、快速排序

1、规则

快速排序的特点：越有序越慢，越乱越快

2、代码

//一次划分函数  核心函数  //返回基准值最终所在下标
int Partition(int *arr, int left, int right)
{
	//先讲arr数组里的[left， right]的第一个值 作为基准值
	int tmp = arr[left];

	while(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);
}

结果：

3、时间复杂度、空间复杂度、稳定性

• 时间复杂度：O(log n)
• 空间复杂度：O(1)
• 稳定性：不稳定

三、总结

• 稳定的排序：直接插入排序、冒泡排序、基数排序、归并排序
• 不稳定的排序：希尔排序、堆排序、选择排序、快速排序

四、快速排序的优化（调整的越乱越好）

1、快排非递归写法

//快速排序的非递归写法
void Quick_Stack(int *arr, int left, int right)
{
	LStack st;
	Init_LStack(&st);
	if(left < right)
	{
		int par = Partition(arr, left, right);
		if(left < par-1)
		{
			Push(&st, left);
			Push(&st, par-1);
		}
		if(par+1 < right)
		{
			Push(&st, par+1);
			Push(&st, right);
		}
	}


	while(!IsEmpty(&st))
	{
		int p;
		int q;
		Pop(&st, &q);
		Pop(&st, &p);

		int par = Partition(arr, p, q);
		if(p < par-1)
		{
			Push(&st, p);
			Push(&st, par-1);
		}

		if(par+1 < q)
		{
			Push(&st, par+1);
			Push(&st, q);
		}
	}

}
//快速排序：时间复杂度O（nlogn） 空间复杂度O（1）  稳定性：不稳定 
void QuickSort(int *arr, int len)
{
	if(len<=1000)  
	{
		return InsertSort(arr, len);
	}


	Quick_Stack(arr, 0, len-1);
}

2、如何优化快排

2.1 数据量过小（n），直接调用直接插入排序

//快速排序：时间复杂度O（nlogn） 空间复杂度O（1）  稳定性：不稳定 
void QuickSort(int* arr, int len)
{
	if (len <= 1000)//优化1：如果n特别小
	{
		return InsertSort(arr, len);
	}
	Quick(arr, 0, len - 1);
}

2.2 三数取中法

void Three_Mid(int* arr, int left, int mid, int right)
{
	if (arr[mid] > arr[right])//保证中间的值小于右边
	{
		int tmp = arr[mid];
		arr[mid] = arr[right];
		arr[right] = tmp;
	
		if (arr[mid] > arr[left])//保证中间的值是三个数中的最小值
		{
			int tmp = arr[mid];
			arr[mid] = arr[left];
			arr[left] = tmp;
		}

}
void Quick(int* arr, int left, int right)
{
	if (left < right)//通过left <right  保证[left, right]这个范围内至少两个数据
	{
		Three_Mid(arr, left, (right + left) / 2, right);//优化2：三数取中法
		int par = Partition(arr, left, right);

		if (left < par - 1)//基准值左半部分  至少有两个值才有必要去递归
		{
			Quick(arr, left, par - 1);
		}
		if (par + 1 < right)//基准值右半部分  至少有两个值才有必要去递归
		{
			Quick(arr, par + 1, right);
		}
	}

}

2.3 随机数法