额外篇 非递归之美：归并排序与快速排序的创新实现

 个人主页：strive-debug

快速排序非递归版本

非递归版本的快速排序是为了解决在空间不够的情况下，利用栈来模拟递归的过程。

递归版本的快速排序是空间换时间，好实现。

实现思路：
1. 创建一个栈，将数组的右边界下标和左边界下标依次入栈。
2. 循环弹出数组的左右边界下标，并对该区间进行单趟排序，确定关键值的下标，分为左右两个区间。
3. 若左区间元素个数大于一个，将左区间右边界下标和左边界下标依次入栈，右区间同理。
4. 重复操作步骤2和3，直到栈为空。

代码演示：

void QuickSortNonR(int* arr, int left, int right)
{
	ST st;
	STInit(&st);
	//先右后左，新进后出
	STPush(&st, right);
	STPush(&st, left);
	while (!STEmpty(&st))
	{
		int begin = STTop(&st);
		STPop(&st);
		int end = STTop(&st);
		STPop(&st);

		int prev = begin;
		int cur = begin + 1;
		int key = begin;
		while (cur <= end)
		{//前后指针排序,找基本点
			if (arr[cur] < arr[key] && ++prev != cur)
			{
				Swap(&arr[prev], &arr[cur]);
			}
			cur++;
		}
		Swap(&arr[prev], &arr[key]);
		key = prev;

		//找到基本点
		//左区间[begin,key-1]
		//右区间[key+1,end]
		if (key + 1 < end)
		{
			STPush(&st,end);
			STPush(&st, key + 1);
		 }
		if (begin < key - 1)
		{
			STPush(&st, key - 1);
			STPush(&st, begin);
		}
		
	}
	STDestroy(&st);
}

```

归并排序

算法思想：
归并排序是基于归并操作的一种有效的排序算法，采用分治法（Divide and Conquer）的思想。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

核心步骤：

void _MergeSort(int* arr, int left, int right, int* tmp)
{
	if (left >= right)
	{
		return;
	}
	int mid = (right + left) / 2;
	//[left,mid]  [mid+1,right]

	_MergeSort(arr, left, mid, tmp);
	_MergeSort(arr, mid + 1, right, tmp);
	//合并
	//[left,mid]  [mid+1,right]
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int index = begin1;
	//对数据进行比较
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] < arr[begin2])
		{
			tmp[index++] = arr[begin1++];
		}
		else
		{
			tmp[index++] = arr[begin2++];
		}
	}
	//跳出循环的结果：
	//要么begin1越界，要么begin2越界
	//有一个被排完了，还有一个没排完
	//那么就要考虑有一个越界，那另一个肯定就没有越界
	//begin2越界
	while (begin1 <= end1)
	{
		tmp[index++] = arr[begin1++];
	}
	//begin1越界
	while (begin2 <= end2)
	{
		tmp[index++] = arr[begin2++];
	}

	//[left,mid],[mid+1,right]
	//把tmp中的数据拷贝回arr中
	for (int i = left; i <= right; i++)
	{
		arr[i] = tmp[i];
	}
}
void MergeSort(int* arr, int n)
{//创建n个下标的数组
	int* tmp = (int*)malloc(sizeof(int) * n);

	_MergeSort(arr, 0, n - 1, tmp);

	free(tmp);
}

```

时间复杂度： O(nlogn)  
空间复杂度： O(n)

接下来为大家介绍不用对比也能排序的版本就是计数排序：

计数排序

操作步骤：
1. 统计相同元素出现次数。
2. 根据统计的结果将序列回收到原来的序列中。

代码实现：

void CountSort(int* arr, int n)
{
	//找最大值和最小值
	int min = arr[0], max = arr[0];
	for (int i = 1; i < n; i++)
	{
		if (arr[i] > max)
			max = arr[i];
		if (arr[i] < min)
			min = arr[i];
	}
	//创建以最大数为下标的数组
	//不要忘记还有0下标
	int range = max - min + 1; 
	int* count = (int*)malloc(sizeof(int) * range);
	if (count == NULL)
	{
		perror("malloc fail");
		return;
	}
	//给数组count设置，将数组中数据设置为0
	memset(count, 0, sizeof(int) * range);
	// 统计次数
	for (int i = 0; i < n; i++)
	{//arr对应下标的数和最小值相减，然后让count对应数的下标的数++
		count[arr[i] - min]++; 
	}
	// 排序
	int j = 0;
	for (int i = 0; i < range; i++)
	{//这里取数是对数组count里对应的数进行操作--
	 //上来看见“i=0然后--”不要慌
		while (count[i]--)
		{
			arr[j++] = i + min;
		}
	}
}

```

特性：
- 计数排序在数据范围集中时，效率很高，但适用范围及场景有限。
- 时间复杂度：O(N + range)
- 空间复杂度：O(range)
- 稳定性： 稳定