引言

在这篇文章中，将继续介绍排序算法：冒泡排序与快速排序：

它们都属于交换排序，即通过两两比较交换，将一个元素放到其正确的位置上，最终实现排序。

冒泡排序

在前面的文章中，已经详细介绍过了冒泡排序：戳我康冒泡排序详解哦
在这里就只给出代码：

//冒泡排序
void bubble_sort(int* nums, int numsSize)
{
    int i = 0;
    int j = 0;
    int x = 0;
    for (i = 0; i < numsSize - 1; i++)
    {
        x = 1;
        for (j = 0; j < numsSize - 1 - i; j++)
        {
            if (nums[j]>nums[j + 1])
            {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
                x = 0;
            }
        }
        if (x)
        {
            break;
        }
    }
}

快速排序

思路

快速排序的思路为：
每次使区间的起始值为基准值，通过两两比较交换，使区间中比基准值小的元素都在其左边，比基准值大的元素都在其右边；
然后再使其左边的区间中的起始位置为基准值，使左边新区间中小于该基准值的在其左边，大于的在其右边；
迭代，直到某次调整后，基准值的左边的区间只有一个元素，就回到上一层，调整上一层区间中基准值右边的区间；
这样迭代，就可以实现最初区域，也就是整个数组的排序。

不难发现，这样的迭代思想与二叉树的前序遍历是非常像的，也具有很好的递归特性。
我们可以递归实现它，有三种实现方式：Hoare版、挖坑法、前后指针法：

实现

我们可以先来递归实现：

Hoare版本

Hoare版本实现时，需要三个参数：待排序的数组，以及需要排序的区间left与right（数组中区间的下标）。

首先，当区间只有一个元素或不存在，即当left大于等于right时，递归终止；
若区间存在，则基准值key为区间的起始值，我们可以通过记录下标来记录这个基准值（keyi）；
存储区间的范围，方便递归；

然后while循环：每次循环中，先right从右向左遍历，找出小于key值的元素的下标；然后left从左往右遍历，找出大于key值的元素的下标。然后交换left与right的两个值。直到left与right相遇后终止循环；
循环结束后，将left与right相遇的那个位置的元素与keyi位置的元素交换。就实现了区间中key前面的元素全部小于key，key后面的元素大于key。即key确认在了正确的位置上

最后递归，将keyi前面的区间与后面的区间分别传参：

 //快速排序hoare版本
void QuickSort1(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	
	int keyi = left;//keyi从最左边开始
	int left2 = left;
	int right2 = right;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(a, left, right);
	}
	Swap(a, keyi, left);

	QuickSort1(a, left2, left - 1);
	QuickSort1(a, right + 1, right2);
}

快排优化

有了上面的实现，相信大家对于快排的思路有了更深的认识，那么快排为什么快呢？

类似于二叉树的递归，最优的情况下：第一层中确认一个元素的位置，第二层中确认2个元素的位置，第三层中确认4个元素的位置…
依次类推，假设有n个元素需要排序，最优情况下，需要logn层（以2为底），时间复杂度为O(nlogn)。

但是，当这个数组已经有序时，当key值选取最左边的值时，它就是区间中的最小（大）值。一层遍历实际只能确认一个元素的位置。排完整个数组就需要n层，时间复杂度为O(n^2)。

显然，这极大的影响的快排的效率。要解决这个问题，就需要key值在区间中是一个不大不小的值：key值越接近区间的中位数，快排的效率就越高。

所以就想到了三数取中的方法：
即比较起始元素，中间位置元素与末尾元素的值，将这三个数中的中位数交换到起始位置，就可以使起始为值的key值是一个不大不小的值，以提高效率：

void Swap(int* a, int m, int n)//交换
{
	int temp = a[n];
	a[n] = a[m];
	a[m] = temp;
}
int GetMidNumi(int* a, int left, int right)//三数取中
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] < a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else //a[left] >= a[mid]
	{
		if (a[right] < a[mid])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

但是这个方案依旧不能解决所有元素相等的情况，就算再三数取中，也不能取一个不大不小的key值。在后面的文章中，可能会介绍解决这种情况的方法。

挖坑法

挖坑法实现时：参数部分与Hoare版本相同。

首先，当区间只有一个元素或不存在，即当left大于等于right时，递归终止；
然后，根据三数取中，选取一个基准值key，将其放在区间的起始位置，坑的初始值就是key的下标；
存储区间的范围，方便递归；

然后while循环：每次循环中，先right从右向左遍历，找出小于key值的元素的下标，然后将这个元素放到坑处，该元素的位置为新的坑；然后left从左往右遍历，找出大于key值的元素的下标，然后将这个元素放到坑处，该元素的位置为新的坑。直到left与right相遇后结束循环；
循环结束后，将key值放进坑中；

最后递归，将keyi前面的区间与后面的区间分别传参：

//快速排序挖坑法
void QuickSort2(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int midi = GetMidNumi(a, left, right);//三数取中，将中间的数放到左位置
	if (a[midi] != a[left])
	{
		Swap(a, left, midi);
	}

	int key = a[left];//key是最左边的数
	int hole = left;
	int left2 = left;//保存left与right的值
	int right2 = right;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;

		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;

	QuickSort2(a, left2, left - 1);
	QuickSort2(a, right + 1, right2);
}

前后指针法

前后指针法实现时，参数列表也与前两个相同；

首先，判断区间；三数取中选key，记录key下标keyi；存储区间的范围，方便递归；
然后，创建两个变量prev与cur，分别表示前后两个位置：prev初始化为区域的起始位置，cur初始化为prev的下一个位置；

然后while循环，当cur所在位置的元素的值小于key值时，prev向后移动一个元素，并交换prev与cur位置的元素；否则，cur向后移动一个元素，prev不动。直到cur移动到区域的末尾时，循环结束；
循环结束后，交换keyi位置的key值与prev位置的值，并将keyi改为prev；
【这个过程的目的其实就是使prev后面的元素（不包括prev，包括cur）都是大于key值的，最后交换prev与keyi位置的值，就是使keyi前面区间的值全部小于key，后面的全部大于key】

最后递归，将keyi前面的区间与后面的区间分别传参：

 //快速排序前后指针法
void QuickSort3(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int midi = GetMidNumi(a, left, right);//三数取中，将中间的数放到左位置
	if (a[midi] != a[left])
	{
		Swap(a, left, midi);
	}

	int keyi = left;//keyi还是从最左边开始
	int prev = keyi;
	int cur = prev + 1;
	while (cur <= right)
	{
		if (a[cur] < a[keyi])
		{
			prev++;
			if (a[prev] != a[cur])
			{
				Swap(a, prev, cur);
			}
		}
		cur++;
	}
	Swap(a, keyi, prev);
	keyi = prev;

	QuickSort3(a, left, keyi - 1);
	QuickSort3(a, keyi + 1, right);
}

由于这个版本实现时，是最方便的，所以最推荐这种写法。

快排非递归版本

当然，所有的递归实现都是可以转化为非递归的，例如之前的斐波那契，可以直接转化为非递归。
但是如果直接非递归实现快排，就会有问题。即当一个左区域已经实现了排序后，返回到上一级区域，再递归到右区域。这个过程是需要知道知道上一级的区域范围的。直接转化非递归显然是不行的。

所以我们需要借助一个结构，来存储上层区域的范围。类似于完成一区域排序后向上返回，这个结构需要满足，后存储的区域先执行排序，就可以从最小的区域向上逐层完成最大的区域的排序，栈这个数据结构恰好符合我们的需求。当栈为空的时候，也就是所有的区域都完成排序的时候。

思路

上面的思路只是模拟从最小的部分向上返回的过程，在要快排一个数组时，完整的过程应该是由最大的区域递归下来到最小区域，再返回上去，所以完整的过程应该为：

先将最大的区域的左右区间入栈，然后进入循环：
循环中先将栈顶的区间取出，对该区间进行排序，将key值放在正确的位置；
然后将keyi后面的区间与前面的区间分别入栈（出栈的时候先出左边的区间）；
再取栈顶的一组区间，排序，再将两个区域入栈，直到入栈的区域小于或等于1个元素时，就不入栈；
下次循环时，出栈的区域就是上级区域的右边；

如此循环，当栈为空时终止循环，排序结束：

实现

外层循环控制每层的入栈与出栈，内层循环控制每个区域中的排序（这个排序可以使用上面实现的三种方法，这里用的是前后指针法）：

// 快速排序 非递归实现（前后指针法）（需要栈辅助实现）
void QuickSortNonR(int* a, int left, int right)
{
	ST st;
	STInit(&st);
	STPush(&st, left);
	STPush(&st, right);
	while (STEmpty(&st) == 0)
	{
		int end = STTop(&st);
		STPop(&st);
		int begin= STTop(&st);
		STPop(&st);

		//前后指针法 
		int midi = GetMidNumi(a, begin, end);//三数取中，将中间的数放到左位置
		if (a[midi] != a[begin])
		{
			Swap(a, begin, midi);
		}
		int keyi = begin;
		int prev = begin;
		int cur = prev + 1;
		while (cur <= end)
		{
			if (a[cur] < a[keyi])
			{
				prev++;
				if (a[prev] != a[cur])
				{
					Swap(a, prev, cur);
				}
			}
			cur++;
		}
		Swap(a, keyi, prev);
		keyi = prev;

		//新的区间入栈（先传右区间再传左区间，取的时候就是先左后右）
		if (keyi + 1 < end)
		{
			STPush(&st, keyi + 1);
			STPush(&st, end);
		}
		if (keyi - 1 >begin)
		{
			STPush(&st, begin);
			STPush(&st, keyi - 1);
		}
	}
	STDestroy(&st);
}

以后的一些不能直接转化为非递归的算法，也都可以借助栈来完成。

总结

到此，关于冒泡排序与快速排序三种实现与非递归实现的内容都已经介绍完了
接下来会继续介绍其他的排序，欢迎持续关注哦

如果大家认为我对某一部分没有介绍清楚或者某一部分出了问题，欢迎大家在评论区提出

如果本文对你有帮助，希望一键三连哦

希望与大家共同进步哦