快速排序算法

其他排序算法参见常见排序算法1
其他排序算法参见常见排序算法2

一、快速排序

1、基本思想

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

2、快速排序的三种方式

• hoare版本
• 挖坑法
• 前后指针版本

二、三数取中法

1、简介

• 此法用代码实现时，可以将它封装成一个函数供快速排序函数调用，使用此函数只是对快排的函数做些优化而已，在快排函数中可以不添加此函数。
• 三数取中法，即在三个数中选取一个中间值。

2、代码

int GetMidIndex(int* a, int begin, int end)
{
	int mid = begin + ((end - begin) >> 1);
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else // begin >= mid
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}

}

代码较为简单，这里就不再过多说明了。

三、hoare版本

1、代码

int PartSort1(int* a, int begin, int end)
{
	int midindex = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[midindex]);


	int key = a[begin];
	int start = begin;

	while (begin < end)
	{
		// end 找小
		while (begin < end && a[end] >= key)
		{
			--end;
		}

		// begin找大
		while (begin < end && a[begin] <= key)
		{
			++begin;
		}

		Swap(&a[begin], &a[end]);
	}
  //最后的交换一定要保证a[begin] < a[start], 所以要从右边走
	Swap(&a[begin], &a[start]);
	return begin;
}

2、代码实现原理

• 首先，先确定一个基准值，上方代码用序列范围内begin位置的值作为基准值并赋值给key，即key就是序列范围内最左边的值。所以开始时，要右边先走。将基准值的位置保存起来，即变量start 保存着基准值的位置。
• begin 为序列范围的最左边，end为序列范围的最右边，用它们作为判断条件，当begin >= end时，说明序列范围内的所有元素已经遍历完了。
• 在begin比end小的前提下，右边（end）先走并寻找比基准值小的值的位置，右边走完才轮到左边走，左边（begin）寻找比基准值大的值的位置，找到后，交换它们的值后再接着循环。
• 最后将begin处的值与start处的值进行交换，则基准值左边的元素比它小，右边的元素比它大。
• 最后返回基准值所处的位置begin。

3、代码实现的原理图

4、左边作为基准值要让右边先走的原因

• 开始时，要让右边先走，如果让左边先走，可能最后一步，如果找不到大于基准值的，会导致begin == end，即相遇，但是右边还没有走，那时所处位置的值一定大于基准值，最后交换就会出现问题。
• 所以一定要让右边先走，即使最后一次找不到小于基准值的，会和左边相遇，而左边此时还没走，一定比基准值小，最后交换肯定不会有问题。
• 如果是右边作为基准值，就得让左边先走。

5、左边作为基准值让右边先走的两种情况

• R（右边）先走，R停下来，L（左边）去遇到R。相遇位置就是R停下来的位置，R停的位置就是比key要小的位置
• R先走，R没有找到比key要小的值，R去遇到了L。相遇位置是L上一轮停下来的位置，该处的值要么就是key的位置，要么比key要小。

四、快速排序递归实现的主框架

快速排序递归实现的主框架与二叉树前序遍历规则非常像，树与二叉树的相关知识和二叉树前序遍历可参见树与二叉树

1、代码

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

	if (right - left + 1 < 10)
	{
		InsertSort(a+left, right - left + 1);
	}
	else
	{
		int div = PartSort1(a, left, right);

		QuickSort(a, left, div - 1);
		QuickSort(a, div + 1, right);
	}
}

2、代码实现原理

• 此函数使用递归的方式实现，所以当left >= right时就不进行后续的操作了。
• 当排序范围小于10时，就直接使用插入排序，插入排序参见常见排序算法2。这样会使效率更高一些。可以不用这样，因为这只是对快速排序进行优化而已。
• 先对序列范围进行排序，基准值的位置用div保存，接着再递归调用自身，只不过把范围分成了两部分，即 [left, div-1] div [div+1, right]，因为div已经处于它应该所处的位置了，所以不用再对它的值进行位置调整。

3、代码实现的原理图

五、挖坑法

1、代码

int PartSort2(int* a, int begin, int end)
{
	int key = a[begin];
	int piti = begin;
	while (begin < end)
	{
		// 右边找小，填到左边的坑里面去。这个位置形成新的坑
		while (begin < end && a[end] >= key)
		{
			--end;
		}
		//此处无需交换值，只需将值赋予pit所在位置即可
		a[piti] = a[end];
		piti = end;

		// 左边找大，填到右边的坑里面去。这个位置形成新的坑
		while (begin < end && a[begin] <= key)
		{
			++begin;
		}

		a[piti] = a[begin];
		piti = begin;
	}

	a[piti] = key;
	return piti;
}

2、代码实现原理

• 将序列范围最左边的位置（begin）的值作为基准值，用变量key保存，并用一个变量piti（坑的位置）保存基准值的位置。
• 和上边的第一种方法一样，用begin与end作为判断条件，只不过是右边找到比key小的值后，将piti（坑的位置）的值修改为该位置的值，再将piti修改为该位置，即该位置变成了坑；接着左边找到比key大的值后，将piti（坑的位置）的值修改为该位置的值，再将piti修改为该位置，即该位置变成了坑。再进行循环，直到循环结束。
• 最后，将piti位置的值置为key，返回piti。

3、代码实现的原理图

六、 前后指针

1、代码

int PartSort3(int* a, int begin, int end)
{
	int midindex = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[midindex]);

	int key = a[begin];
	int prev = begin;
	int cur = begin + 1;

	while (cur <= end)
	{
		// cur找小，把小的往前翻，大的往后翻
		if (a[cur] < key && ++prev != cur)
			Swap(&a[cur], &a[prev]);

		++cur;
	}

	Swap(&a[begin], &a[prev]);

	return prev;
}

2、代码实现原理

• 首先还是一样，取序列范围内最左边的值作为基准值，前指针prev也是取的该位置，cur则是prev的下一位。
• 用cur与end作为判断条件，当cur大于end时，说明范围序列已经排序好了。
• cur每次循环都自增一，但prev只有当cur处的值小于key时才会自增，当prev下一位的位置不是cur时，说明prev下一位的值比key大，prev位置的值可以与cur位置的值进行交换，否则不进行交换，继续循环。
• 最后将begin位置的值与prev位置的值进行交换，因为prev处的值一定小于begin处的值，最后返回prev。

3、动图展示代码实现的原理

七、快速排序的特性总结

• 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序。
• 时间复杂度：O(N*logN)。
• 空间复杂度：O(logN)，因为递归开辟了logN。
• 稳定性：不稳定。
  

本文到这里就结束了，如有错误或者不清楚的地方欢迎评论或者私信
创作不易，如果觉得写得不错，请务必一键三连