数据结构高阶--八大排序汇总

什么是排序？

????排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
✍️排序的稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

排序的分类

插入排序

直接插入排序

⛅基本思想：把待排序的数逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列

✍️一般地，我们把第一个看作是有序的，所以我们可以从第二个数开始往前插入，使得前两个数是有序的，然后将第三个数插入直到最后一个数插入

口头说还是太抽象了，那么我们用一个具体例子来介绍一下吧

所以直接插入排序的代码实现如下：

void InsertSort(int* a, int n)
{
	int i = 0;
	for (i = 0; i < n - 1; i++)
	{
		int end = i;
		//先定义一个变量，将要插入的数保存起来
		int x = a[end + 1];
		//直到后面的数比前面大的时候就不移动，就直接把这个数放在end的后面
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = x;
	}
}

时间复杂度和空间复杂度

⛅时间复杂度： 第一趟end最多往前移动1次，第二趟是2次……第n-1趟是n-1次，所以总次数是1+2+3+……+n-1=n*(n-1)/2，所以说时间复杂度是O(n^2)

最好的情况： 顺序
最坏的情况： 逆序

⛅空间复杂度：由于没有额外开辟空间，所以空间复杂度为O(1)

直接插入排序稳定性

✍️直接插入排序在遇到相同的数时，可以就放在这个数的后面，就可以保持稳定性了，所以说这个排序是稳定的。

希尔排序

????基本思想：希尔排序是建立在直接插入排序之上的一种排序，希尔排序的思想上是把较大的数尽快的移动到后面，把较小的数尽快的移动到后面。先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。（直接插入排序的步长为1），这里的步长不为1，而是大于1，我们把步长这个量称为gap，当gap>1时，都是在进行预排序，当gap==1时，进行的是直接插入排序
????同样的我们看图说话！

我们先来一个单趟的排序：

int end = 0;
int x = a[end + gap];
while (end >= 0)
{
	if (a[end] > x)
	{
		a[end + gap] = a[end];
		end =end - gap;
	}
	else
	{
		break;
	}
}
a[end + gap] = x;

这里的单趟排序的实现和直接插入排序差不多，只不过是原来是gap = 1，现在是gap了。
由于我们要对每一组都进行排序，所以我们可以一组一组地排，像这样：

// gap组
for (int j = 0; j < gap; j++)
{
	int i = 0;
	for (i = 0; i < n-gap; i+=gap)
	{
		int end = i;
		int x = a[end + gap];
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + gap] = a[end];
				end -= gap;
			}
			else
			{
				break;
			}
		}
		a[end + gap] = x;
	}
}

也可以对代码进行一些优化，直接一起排序，不要一组一组地，代码如下：

int i = 0;
for (i = 0; i < n - gap; i++)// 一起预排序
{
	int end = i;
	int x = a[end + gap];
	while (end >= 0)
	{
		if (a[end] > x)
		{
			a[end + gap] = a[end];
			end -= gap;
		}
		else
		{
			break;
		}
	}
	a[end + gap] = x;
}

当gap>1时，都是在进行预排序，当gap==1时，进行的是直接插入排序。

• gap越大预排越快，预排后越不接近有序
• gap越小预排越慢，预排后越接近有序
• gap==1时，进行的是直接插入排序。
• 所以接下来我们要控制gap，我们可以让最初gap为n，然后一直除以2直到gap变成1，也可以这样：gap = gap/3+1。只要最后一次gap为1就可以了。

所以最后的代码实现如下：

void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)// 不要写等于，会导致死循环
	{
		// gap > 1 预排序
		// gap == 1 插入排序
		gap /= 2;
		int i = 0;
		for (i = 0; i < n - gap; i++)// 一起预排序
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = x;
		}
	}
}

时间复杂度和空间复杂度

⛅时间复杂度：外层的循环次数，复杂度是O(logN)

每一组的数的个数大概是N/gap，总共有N/n/gap个组，所以调整的次数应该是（1+2+......+N/gap-1）*gap，所以我们分成两种极端来看待这个问题：

当gap很大，也就是gap = N/2的时候，调整的次数是N/2，也就是O(N)

当gap很小，也就是gap = 1的时候，按道理来讲调整的次数应该（1+2+......+N-1）*gap，应该是O(n^2)，但是这时候应该已经接近有序，次数没有那么多，所以我们不如就看作时间复杂度为O(N)

综上：希尔排序的时间复杂度应该是接近O(N*logN)

⛅空间复杂度：由于没有额外开辟空间，所以空间复杂度为O(1)

希尔排序稳定性

✍️我们可以这样想，相同的数被分到了不同的组，就不能保证原有的顺序了，所以说这个排序是不稳定的。

选择排序

直接选择排序

????基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完

????同样的我们看图说话！

整体排序就是begin往前走，end往后走，相遇就停下，所以整体代码实现如下：

void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		int i = 0;
		for (i = begin; i <= end; i++)
		{
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
			if (a[i] < a[mini])
			{
				mini = i;
			}
			// 如果maxi和begin相等的话，要对maxi进行修正
			if (maxi == begin)
			{
				maxi = mini;
			}
			swap(a[begin], a[mini]);
			swap(a[end], a[maxi]);
			begin++;
			end--;
		}
	}
}

这里说明一下，其中加了一段修正maxi的代码，就是为了防止begin和maxi相等时，mini与begin交换会导致maxi的位置发生变化，而此时begin就是maxi，若此时交换maxi和end，换到end处的不是最大值，而是最小值mini，所以提前将mini赋值给maxi，当begin与mini交换的时候，mini处就是begin也就是最大值，这样maxi与end交换就不会出现错误

时间复杂度和空间复杂度

⛅ 时间复杂度：第一趟遍历n-1个数，选出两个数，第二趟遍历n-3个数，选出两个数……最后一次遍历1个数（n为偶数）或2个数（n为奇数），所以总次数是n-1+n-3+……+2，所以说时间复杂度是O(n^2)

✍️最好的情况： O(n^2)（顺序）
✍️最坏的情况： O(n^2)（逆序）

⛅空间复杂度：由于没有额外开辟空间，所以空间复杂度为O(1)

选择排序稳定性

直接选择排序是不稳定的

举个例子：假设顺序是3 2 3 0，遍历选出最小的0，此时0与3交换，两个3的前后顺序明显发生了变化，所以是不稳定的

堆排序

数据结构初阶--堆排序+TOPK问题 - 一只少年a - 博客园 (cnblogs.com)

这篇已经介绍过了

补充一点：堆排序是不稳定的

交换排序

冒泡排序

????基本思想：它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成（依次向后比较两个元素，将大的元素放到后面）

????同样的我们看图说话！

冒泡排序整体代码实现如下：

void BubbleSort(int* a, int n)
{
	int i = 0;
	//外层循环，需要进行几次排序
	for (i = 0; i < n - 1; i++)
	{
		int j = 0;
		//内部循环，比较次数
		for (j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				swap(a[j], a[j + 1]);
			}
		}
	}
}

✍️我们思考一个问题，假设当前的序列已经有序了，我们有没有什么办法直接结束排序？就像图中的情况，在第三次排序的时候已经有序，后面的比较是没必要的

这当然是有的，我们可以定义一个exchange的变量，如果这趟排序发生交换就把这个变量置为1，否则就不变，不发生交换的意思就是该序列已经有序了，利用这样一个变量我们就可以直接结束循环了

优化后的冒泡排序代码：

void BubbleSort(int* a, int n)
{
	int i = 0;
	for (i = 0; i < n - 1; i++)
	{
		int exchange = 0;
		int j = 0;
		for (j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				exchange = 1;
				Swap(&a[j], &a[j + 1]);
			}
		}
		// 不发生交换
		if (exchange == 0)
			break;
	}
}

时间复杂度和空间复杂度

⛅时间复杂度： 第一趟最多比较n-1次，第二趟最多比较n-2次……最后一次最多比较1次，所以总次数是n-1+n-2+……+1，所以说时间复杂度是O(n^2)

最好的情况： O(n)（顺序）
最坏的情况： O(n^2)（逆序）

⛅空间复杂度：由于没有额外开辟空间，所以空间复杂度为O(1)

冒泡排序稳定性

✍️冒泡排序在比较遇到相同的数时，可以不进行交换，这样就保证了稳定性，所以说冒泡排序数稳定的。

快速排序（递归版本）

????基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

✍️快速排序的基本流程

• 首先在待排序列中确定一个基准值，遍历整个序列，将小于（可包含等于）基准值的元素放到基准值左边，将大于（可包含等于）基准值的元素放到其右边。（降序序列可将位置调整）
• 此时基准值将序列分割成俩个部分，左边的元素全部小于基准值，右边的元素全部大于基准值
• 将分割的左右俩部分进行如上俩步操作，实则为递归
• 通过递归将左右俩侧排好序，直至分割的小序列个数为1，排序全部完成

hoare版本

????基本思想：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

????同样的我们看图说话！

????我们要遵循一个原则：关键词取左，右边先找小再左边找大；关键词取右，左边找先大再右边找小。

????一次过后，2也就来到了排序后的位置，接下来我们就是利用递归来把key左边区间和右边的区间递归排好就可以了，如下：

递归左区间:[left, key-1] key 递归右区间:[key+1, right]

hoare版本找key值代码实现如下：

int PartSort1(int* a, int left, int right)
{
	int key = left;
	while (left < right)
	{
		// 右边找小
		while (left < right && a[right] >= a[key])
		{
			right--;
		}

		// 左边找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[key], &a[left]);

	return left;
}

快排代码实现如下：

void QuickSort(int* a, int left, int right)
{
	if (left > right)
		return;

	int div = PartSort1(a, left, right);

	// 两个区间 [left, div-1] div [div+1, right]
	QuickSort(a, left, div - 1);
	QuickSort(a, div + 1, right);
}

✍️我们考虑这样一种情况，当第一个数是最小的时候，顺序的时候会很糟糕，因为每次递归right都要走到头，看下图：

为了优化这里写了一个三数取中的代码，三数取中就是在序列的首、中和尾三个位置选择第二大的数，然后放在第一个位置，这样就防止了首位不是最小的，这样也就避免了有序情况下，情况也不会太糟糕。

下面是三数取中代码：

int GetMidIndex(int* a, int left, int right)
{
	int mid = left + (right - left) / 2;
	if (a[mid] > a[left])
	{
		if (a[right] > a[mid])
		{
			return mid;
		}
		// a[right] <= a[mid]
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	// a[mid] <= a[left]
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		// a[mid] <= a[right]
		else if (a[left] > a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
}

所以加上三数取中优化后的代码如下：

int PartSort1(int* a, int left, int right)
{
	int index = GetMidIndex(a, left, right);
	Swap(&a[index], &a[left]);
	int key = left;
	while (left < right)
	{
		// 右边找小
		while (left < right && a[right] >= a[key])
		{
			right--;
		}

		// 左边找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[key], &a[left]);

	return left;
}

挖坑法

????基本思想：设定一个基准值(一般为序列的最左边元素，也可以是最右边的元素)此时最左边的是一个坑。开辟两个指针，分别指向序列的头结点和尾结点(选取的基准值在左边，则先从右边出发。反之，选取的基准值在右边，则先从左边出发)。 从右指针出发依次遍历序列，如果找到一个值比所选的基准值要小，则将此指针所指的值放在坑里，左指针向前移。 后从左指针出发(选取的基准值在左边，则后从左边出发。反之，选取的基准值在右边，则后从右边出发)，依次便利序列，如果找到一个值比所选的基准值要大，则将此指针所指的值放在坑里，右指针向前移。 依次循环步骤，直到左指针和右指针重合时，我们把基准值放入这两个指针重合的位置。

????同样的我们看图说话！

挖坑法我们要遵循一个原则：坑在左，右边找小；坑在右，左边找大。

挖坑法代码实现如下（加了三数取中算法）：

int PartSort2(int* a, int left, int right)
{
	int index = GetMidIndex(a, left, right);
	Swap(&a[index], &a[left]);
	//pivot就是那个坑
	int pivot = left;
	int key = a[pivot];
	while (left < right)
	{
		// 坑在左边，右边找小
		while (left < right && a[right] >= key)
		{
			right--;
		}
		Swap(&a[pivot], &a[right]);
		pivot = right;

		// 坑在右边边，右边找大
		while (left < right && a[left] <= key)
		{
			left++;
		}
		Swap(&a[pivot], &a[left]);
		pivot = left;
	}
	a[pivot] = key;
	return pivot;
}

前后指针法

????基本思想：前后指针法就是有两个指针prev和cur，cur个在前，prev在后，cur在前面找小，找到了，prev就往前走一步，然后交换prev和cur所在位置的值，然后cur继续找小，直到cur走到空指针的位置就结束，最后将prev的值与key交换就完成了一次分割区间的操作

????同样的我们看图说话！

代码实现：

int PartSort3(int* a, int left, int right)
{
	int index = GetMidIndex(a, left, right);
	Swap(&a[index], &a[left]);
	int key = a[left];
	int prev = left;
	int cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < key)
		{
			prev++;
			if (prev != cur)
				Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	Swap(&a[prev], &a[left]);
	return prev;
}

小区间优化快速排序

????小区间优化原理：当快速排序在递归过程中一直切分区间时，最后会被分成很小的区间，当区间中的数据个数很小时，其实这是已经是没有必要进行再分割的，且最后一层基本上占据了快速排序一半的递归，这是我们可以选择其他的排序来解决这个小区间的排序

????还有一个我们要思考的问题就是最后这段小区间用什么排序比较好？

希尔排序适应的是比较多的数据才有优势，堆排序也不行，需要建堆，有点杀鸡用牛刀的感觉，其他三个插入排序、选择排序和冒泡排序相比，还是插入排序比较优，所以我们小区间选择用插入排序进行排序

void QuickSort(int* a, int left, int right)
{
	if (left > right)
		return;
	
	int div = PartSort3(a, left, right);
	// 两个区间 [left, div-1] div [div+1, right]
	if (div - 1 - left > 10)
	{
		QuickSort(a, left, div - 1);
	}
	else
	{
		InsertSort(a + left, (div - 1) - left + 1);
	}

	if (right - div - 1 > 10)
	{
		QuickSort(a, div + 1, right);
	}
	else
	{
		InsertSort(a + div + 1, right - (div + 1) + 1);
	}

}

快速排序（非递归版本）

???? 基本思想：利用栈来模拟实现递归调用的过程，利用压栈的顺序来实现排序的顺序。
给大家看一个利用栈模拟实现的动图

????同样的我们看图说话！

我们拿数组arr=[5,2,4,7,9,1,3,6]来举个例子：

第一步：我们先把区间的右边界值7进行压栈，然后把区间的左边界值0进行压栈，那我们取出时就可以先取到左边界值，后取到后边界值

第二步：我们获取栈顶元素，先取到0给left，后取到7给right，进行单趟排序

第三步：第一趟排完后，区间被分为左子区间和右子区间。为了先处理左边，所以我们先将右子区间压栈，分别压入7和5，然后压入左子区间，3和0

第四步：取出0和3进行单趟排序

第五步：此时左子区间又被划分为左右两个子区间，但是右子区间只有4一个值，不再压栈，所以只入左子区间，将1和0压栈

第六步：取出0和1进行单趟排序

第七步：至此，左子区间全部被排完，这时候才可以出5和7排右子区间，是不是很神奇？这个流程其实和递归是一模一样的，顺序也没变，但解决了递归的致命缺陷——栈溢出。后面的流程就不一一展现了

void QuickSortNonR(int* a, int left, int right)
{
	stack<int> s;
	s.push(right);
	s.push(left);
	
	while (!s.empty())
	{
		int newLeft = s.top();
		s.pop();
		int newRight = s.top();
		s.pop();
		
		//挖洞法
		int div = PartSort2(a, newLeft, newRight);
		// 两个区间 [left, div-1] div [div+1, right]
		// 压右区间
		if (div + 1 < newRight)
		{
			s.push(newRight);
			s.push(div + 1);
		}

		// 压左区间
		if (newLeft < div - 1)
		{
			s.push(div - 1);
			s.push(newLeft);
		}
	}
}

快速排序时间复杂度和空间复杂度

⛅空间复杂度：

最优的情况下空间复杂度为：O(logN) ；每一次都平分数组的情况

最差的情况下空间复杂度为：O( N ) ；退化为冒泡排序的情况

⛅时间复杂度:

快速排序最优的情况下时间复杂度为：O( NlogN )

快速排序最差的情况下时间复杂度为：O( N^2 )

快速排序的平均时间复杂度也是：O(NlogN)

快速排序稳定性

快速排序显然是不稳定的，我们试想一下：5 ....5...1....5，这种情况，交换第一个5和1的时候，显然三个5的前后顺序发生了变化，是不稳定的

归并排序

递归版本

???? 基本思想：（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
????归并条件： 左区间有序 右区间有序

????同样的我们看图说话！

上半部分递归树为将当前长度为 n 的序列拆分成长度为 n/2 的子序列，下半部分递归树为合并已经排序的子序列

再来一张动态图应该更好理解吧~

归并排序代码实现：

void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
		return;
	int mid = left + (right - left) / 2;
	// 归并条件：左区间有序 右区间有序 
	// 如何做到？递归左右区间
	// [left, mid] [mid + 1, right]
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);

	//归并
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = right;
	int i = left;
	//对归并的数组进行排序，暂存到tmp数组中
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	//两个while循环将两个归并数组未加入tmp中的元素加入到tmp当中
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}

	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	//将tmp数组的值赋值给数组a，因为a是指针，所以对形参进行修改对应实参也会修改
	for (i = left; i <= right; i++)
	{
		a[i] = tmp[i];
	}
}
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
	tmp = NULL;

}

归并排序时间复杂度和空间复杂度

⛅时间复杂度：O(N*logN)

⛅空间复杂度： O(N)，要来一个临时空间存放归并好的区间的数据

归并排序稳定性

归并排序在遇到相同的数时，可以就先将放前一段区间的数，再放后一段区间的数就可以保持稳定性了，所以说这个排序是稳定的

非递归版本

???? 基本思想： 这里我们用循环来实现这个非递归的归并排序，我们可以先两两一组，在四个四个一组归并……

????同样的我们看图说话！(分两种情况讨论)

特殊情况（元素个数为2^i）

根据上面这个图，我们可以很快的写出一个框架，例如下面的代码：

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	int gap = 1;//每趟合并后序列的长度
	while (gap < n)//合并趟数的结束条件是：最后合并后的序列长度>=数组元素的个数
	{
		int i = 0;
		//每趟进行两两合并
		for (i = 0; i < n; i += 2 * gap)
		{
			// [i, i+gap-1] [i+gap, i+2*gap-1]
			
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			int index = i;
			
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}

			int j = 0;
			for (j = i; j <= end2; j++)
			{
				a[j] = tmp[j];
			}
		}
		gap *= 2;
	}
	free(tmp);
	tmp = NULL;
}

一般情形（数组的元素个数不一定是2^i ）

虽然元素个数不一定是 2^i 个，但是任意元素的个数为n，都必然可以拆写成 2^j+m 个元素的情况

由图可知，这种情况下存在两种特殊情况：

• 橙色箭头代表无需合并，因为找不到配对的元素，造成该情况的原因是归并过程中，右半区间不存在，此时我们可以不进行这次归并，直接跳出循环，也就是begin2>=n的时候，我们就break跳出这次循环，不进行归并
• 绿色箭头代表两个长度不相等的元素也要合并，归并过程中，左区间存在，右区间也存在，但是右区间和左区间长度不一样，就意味着end2>=n的情况，此时我们只需要对end2进行调整，使得右区间范围缩小，不越界，就可以继续归并

我们可以看到这种情况在一次归并中仅存在一次或者零次。

所以调整后的代码如下：

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	int gap = 1;
	while (gap < n)
	{
		int i = 0;
		for (i = 0; i < n; i += 2 * gap)
		{
			// [i, i+gap-1] [i+gap, i+2*gap-1]
			// 两种需要调整的情况：
			// 1.右区间不存在
			// 2.正要归并的右区间和左区间长度不一样
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			int index = i;
			// 情况1：当右区间不存在的时候，右区间的范围是[begin2,end2]，所以begin2越界，就代表着右区间不存在的情况
			if (begin2 >= n)
				break;
			// 情况2，左右区间长度不一，同样此时右区间是存在的，但是end2越界，就代表了左右区间长度不一的情况，此时我们需要做调整
			//将end2的长度设置成n-1，将原来的end2(越界)设置成数组a的最后一个元素的位置，因为不平衡的区间最后一个元素一定是数组a的最后一个元素
			if (end2 >= n)
				end2 = n - 1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}

			int j = 0;
			for (j = i; j <= end2; j++)
			{
				a[j] = tmp[j];
			}
		}
		gap *= 2;
	}
	free(tmp);
	tmp = NULL;
}

????这样非递归的归并排序就这样被我们实现了。非递归归并排序的实现的难点不在框架，而在边界控制，我们要把边界控制的到位，这样就能够很好地实现这个非递归

计数排序

???? 基本思想： 它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。 当然这是一种牺牲空间换取时间的做法

????同样的我们看图说话！

我们可以先计数出这个序列数据的范围也就是range = max - min + 1，最大值和最小值都可以通过遍历一遍序列来选出这两个数。然后我们可以开一个大小为range的计数的空间count中，然后将序列中的每一个数都减去min，然后映射到count这个空间中，然后我们再一次取出并加上min依次放进原数组空间中，这样我们就顺利地完成了排序

具体代码实现如下：

void CountSort(int* a, int n)
{
	int min = a[0];
	int max = a[0];
	int i = 0;
	for (i = 1; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}

	int range = max - min + 1;

	int* count = (int*)malloc(sizeof(int) * range);
	if (count == NULL)
	{
		printf("malloc error\n");
		exit(-1);
	}
	// 初始化开辟的空间
	memset(count, 0, sizeof(int) * range);
	for (i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}

	int index = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[index++] = i + min;
		}
	}

	free(count);
	count = NULL;
}

计数排序时间复杂度和空间复杂度

⛅空间复杂度： O(N)，要来一个临时空间存放归并好的区间的数据

⛅时间复杂度：O(MAX(N,范围))（以空间换时间）

计数排序稳定性

计数排序在我们这个实现里是不稳定的

排序比较

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
直接插入排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
希尔排序	O(nlogn~n^2)	O(n^1.3)	O(n^2)	O(1)	不稳定
直接选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
冒泡排序	O(n^2)	O(n)	O(n^2)	O(1)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n^2)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定