* 快速排序的深入优化探讨

在算法设计领域，快速排序因其卓越的平均性能与广泛的应用场景而备受推崇。自1960年Tony Hoare提出以来，它已成为许多编程语言标准库中的核心排序方法。然而，随着数据规模的不断扩大和计算需求的日益复杂化，对快速排序进行更深入的优化显得尤为重要。本博客将聚焦于快速排序的高级优化技巧，包括Hoare和Lomuto的单趟排序方法，以及改进性能的三路划分算法。这些技术不仅进一步提升了排序效率，还增强了算法面对各类数据集时的健壮性。我们将通过理论解析与实际应用示例，为专业人士和算法爱好者提供深度洞察。

文章目录

快速排序的深优入化探讨
排序OJ
总结

一、快排性能的关键点分析

决定快排性能的关键点是每次单趟排序后，key对数组的分割，如果每次选key基本二分居中，那么快排的递归树就是颗均匀的满⼆叉树，性能最佳。但是实践中虽然不可能每次都是二分居中，但是性能也还是可控的。但是如果出现每次选到最小值/最大值，划分为0个和N-1的子问题时，时间复杂度为 O(N^2)，数组序列有序时就会出现这样的问题，前面已经用三数取中或者随机选key解决了这个问题，也就是说我们解决了绝大多数的问题，但是现在还是有一些场景没解决(数组中有大量重复数据时)，类似下面的代码。

// 数组中有多个跟key相等的值
int a[] = { 6,1,7,6,6,6,4,9 };
int a[] = { 3,2,3,3,3,3,2,3 };
// 数组中全是相同的值
int a[] = { 2,2,2,2,2,2,2,2 };

以下是《算法导论》书籍中给出的hoare和lomuto给出的快排的单趟排序的伪代码：

hoare和lomuto单趟排序代码分析：

数组中有大量重复数据时，快排单趟选key划分效果对象：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>


void PrintArray(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}


void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

// hoare
// [left, right]
int PartSort1(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		// 右边找⼩
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		// 左边找⼤
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}

// 前后指针
int PartSort2(int* a, int left, int right)
{
	int prev = left;
	int cur = left + 1;
	int keyi = left;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}


typedef struct
{
	int leftKeyi;
	int rightKeyi;
}KeyWayIndex;


// 三路划分
KeyWayIndex PartSort3Way(int* a, int left, int right)
{
	int key = a[left];
	// left和right指向就是跟key相等的区间
	// [开始, left-1][left, right][right+1, 结束]
	int cur = left + 1;
	while (cur <= right)
	{
		// 1、cur遇到⽐key⼩，⼩的换到左边，同时把key换到中间位置
		// 2、cur遇到⽐key⼤，⼤的换到右边
		if (a[cur] < key)
		{
			Swap(&a[cur], &a[left]);
			++cur;
			++left;
		}
		else if (a[cur] > key)
		{
			Swap(&a[cur], &a[right]);
			--right;
		}
		else
		{
			++cur;
		}
	}
	KeyWayIndex kwi;
	kwi.leftKeyi = left;
	kwi.rightKeyi = right;
	return kwi;
}

void TestPartSort1()
{
	int a1[] = { 6,1,7,6,6,6,4,9 };
	int a2[] = { 3,2,3,3,3,3,2,3 };
	int a3[] = { 2,2,2,2,2,2,2,2 };
	PrintArray(a1, sizeof(a1) / sizeof(int));
	int keyi1 = PartSort1(a1, 0, sizeof(a1) / sizeof(int) - 1);
	PrintArray(a1, sizeof(a1) / sizeof(int));
	printf("hoare keyi:%d\n\n", keyi1);
	PrintArray(a2, sizeof(a2) / sizeof(int));
	int keyi2 = PartSort1(a2, 0, sizeof(a2) / sizeof(int) - 1);
	PrintArray(a2, sizeof(a2) / sizeof(int));
	printf("hoare keyi:%d\n\n", keyi2);
	PrintArray(a3, sizeof(a3) / sizeof(int));
	int keyi3 = PartSort1(a3, 0, sizeof(a3) / sizeof(int) - 1);
	PrintArray(a3, sizeof(a3) / sizeof(int));
	printf("hoare keyi:%d\n\n", keyi3);
}

void TestPartSort2()
{
	int a1[] = { 6,1,7,6,6,6,4,9 };
	int a2[] = { 3,2,3,3,3,3,2,3 };
	int a3[] = { 2,2,2,2,2,2,2,2 };
	PrintArray(a1, sizeof(a1) / sizeof(int));
	int keyi1 = PartSort2(a1, 0, sizeof(a1) / sizeof(int) - 1);
	PrintArray(a1, sizeof(a1) / sizeof(int));
	printf("前后指针 keyi:%d\n\n", keyi1);
	PrintArray(a2, sizeof(a2) / sizeof(int));
	int keyi2 = PartSort2(a2, 0, sizeof(a2) / sizeof(int) - 1);
	PrintArray(a2, sizeof(a2) / sizeof(int));
	printf("前后指针 keyi:%d\n\n", keyi2);
	PrintArray(a3, sizeof(a3) / sizeof(int));
	int keyi3 = PartSort2(a3, 0, sizeof(a3) / sizeof(int) - 1);
	PrintArray(a3, sizeof(a3) / sizeof(int));
	printf("前后指针 keyi:%d\n\n", keyi3);
}


void TestPartSort3()
{
	//int a0[] = { 6,1,2,7,9,3,4,5,10,4 };
	int a1[] = { 6,1,7,6,6,6,4,9 };
	int a2[] = { 3,2,3,3,3,3,2,3 };
	int a3[] = { 2,2,2,2,2,2,2,2 };
	PrintArray(a1, sizeof(a1) / sizeof(int));
	KeyWayIndex kwi1 = PartSort3Way(a1, 0, sizeof(a1) / sizeof(int) - 1);
	PrintArray(a1, sizeof(a1) / sizeof(int));
	printf("3Way keyi:%d,%d\n\n", kwi1.leftKeyi, kwi1.rightKeyi);
	PrintArray(a2, sizeof(a2) / sizeof(int));
	KeyWayIndex kwi2 = PartSort3Way(a2, 0, sizeof(a2) / sizeof(int) - 1);
	PrintArray(a2, sizeof(a2) / sizeof(int));
	printf("3Way keyi:%d,%d\n\n", kwi2.leftKeyi, kwi2.rightKeyi);
	PrintArray(a3, sizeof(a3) / sizeof(int));
	KeyWayIndex kwi3 = PartSort3Way(a3, 0, sizeof(a3) / sizeof(int) - 1);
	PrintArray(a3, sizeof(a3) / sizeof(int));
	printf("3Way keyi:%d,%d\n\n", kwi3.leftKeyi, kwi3.rightKeyi);
}

int main()
{
	TestPartSort1();
	TestPartSort2();
	TestPartSort3();

	return 0;
}

三路划分算法解析：

当面对有大量跟key相同的值时，三路划分的核心思想有点类似hoare的左右指针和lomuto的前后指针的结合。核心思想是把数组中的数据分为三段【比key小的值】【和key相等的值】【比key大的值】，所以叫做三路划分算法。结合下图，理解⼀下实现思想：

1. key默认取left位置的值。

2. left指向区间最左边，right指向区间最后边，cur指向left+1位置

3. cur遇到比key小的值后跟left位置交换，换到左边，left++，cur++

4. cur遇到比key大的值后跟right位置交换，换到右边，right--

5. cur遇到跟key相等的值后，cur++

6. 直到cur>right结束

// 三路划分
KeyWayIndex PartSort3Way(int* a, int left, int right)
{
	int key = a[left];
	// left和right指向就是跟key相等的区间
	// [开始, left-1][left, right][right+1, 结束]
	int cur = left + 1;
	while (cur <= right)
	{
		// 1、cur遇到⽐key⼩，⼩的换到左边，同时把key换到中间位置
		// 2、cur遇到⽐key⼤，⼤的换到右边
		if (a[cur] < key)
		{
			Swap(&a[cur], &a[left]);
			++cur;
			++left;
		}
		else if (a[cur] > key)
		{
			Swap(&a[cur], &a[right]);
			--right;
		}
		else
		{
			++cur;
		}
	}
	KeyWayIndex kwi;
	kwi.leftKeyi = left;
	kwi.rightKeyi = right;
	return kwi;
}

三种快排单趟排序运行结果分析：

从下面的运行结果分析，无论是hoare，还是lomuto的前后指针法，面对key有大量重复时，划分都不是很理想。三数取中和随机选key，都不能很好的解决这里的问题。但是三路划分算法，把跟key相等的值都划分到了中间，可以很好的解决这里的问题。

二. 排序OJ

. - 力扣（LeetCode）

下面来看看这个OJ题，用快排的时候，传统的hoare和lomuto的方法，过不了这个题目。堆排序、归并和希尔是可以过的，其他几个O(N^2)也不过了，因为这个题的测试用例中不仅仅有数据很多的大数组，也有⼀些特殊数据的数组，如大量重复数据的数组。堆排序、归并和希尔不是很受数据样本的分布和形态的影响，但是快排会，因为快排要选key，每次key当趟分割都很偏，就会出现效率退化问题。

这里快排的解决方案讲两种：

1. 上面讲的三路划分。

2. C++STL sort中用的introspective sort(内省排序)。（introsort是由David Musser在1997年设计的排序算法）

lomuto的快排跑排序OJ代码

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int begin = left;
	int end = right;
	// 随机选key
	int randi = left + (rand() % (right - left+1));
	// printf("%d\n", randi);
	Swap(&a[left], &a[randi]);
	int prev = left;
	int cur = prev + 1;
	int keyi = left;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	keyi = prev;
	// [begin, keyi-1] keyi [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

int* sortArray(int* nums, int numsSize, int* returnSize) 
{
	srand(time(0));
	QuickSort(nums, 0, numsSize - 1);
	*returnSize = numsSize;
	return nums;
}

运行结果：

三路划分的快排跑排序OJ代码

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int begin = left;
	int end = right;
	// 随机选key
	int randi = left + (rand() % (right - left));
	Swap(&a[left], &a[randi]);
	// 三路划分
	// left和right指向就是跟key相等的区间
 // [begin, left-1] [left, right] right+1, end]
	int key = a[left];
	int cur = left + 1;
	while (cur <= right)
	{
		// 1、cur遇到⽐key⼩，⼩的换到左边，同时把key换到中间位置
		// 2、cur遇到⽐key⼤，⼤的换到右边
		if (a[cur] < key)
		{
			Swap(&a[cur], &a[left]);
			++left;
			++cur;
		}
		else if (a[cur] > key)
		{
			Swap(&a[cur], &a[right]);
			--right;
		}
		else
		{
			++cur;
		}
	}
	// [begin, left-1] [left, right] right+1, end]
	QuickSort(a, begin, left - 1);
	QuickSort(a, right + 1, end);
}


int* sortArray(int* nums, int numsSize, int* returnSize) 
{
	srand(time(0));
	QuickSort(nums, 0, numsSize - 1);
	*returnSize = numsSize;
	return nums;
}

introsort的快排跑排序OJ代码

introsort是introspective sort采用了缩写，他的名字其实表达了他的实现思路，他的思路就是进行自我侦测和反省，快排递归深度太深（sgi stl中使用的是深度为2倍排序元素数量的对数值）那就说明在这种数据序列下，选key出现了问题，性能在快速退化，那么就不要再进行快排分割递归了，改换为堆排序进行排序。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 选出左右孩⼦中⼤的那⼀个
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	// 建堆 -- 向下调整建堆 -- O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
	// ⾃⼰先实现 -- O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0);
		--end;
	}
}

void InsertSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		int end = i - 1;
		int tmp = a[i];
		// 将tmp插⼊到[0,end]区间中，保持有序
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

void IntroSort(int* a, int left, int right, int depth, int defaultDepth)
{
	if (left >= right)
		return;

	// 数组⻓度⼩于16的⼩数组，换为插⼊排序，简单递归次数
	if (right - left + 1 < 16)
	{
		InsertSort(a + left, right - left + 1);
		return;
	}
	// 当深度超过2*logN时改⽤堆排序
	if (depth > defaultDepth)
	{
		HeapSort(a + left, right - left + 1);
		return;
	}
	depth++;
	int begin = left;
	int end = right;
	// 随机选key
	int randi = left + (rand() % (right - left));
	Swap(&a[left], &a[randi]);
	int prev = left;
	int cur = prev + 1;
	int keyi = left;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	keyi = prev;
	// [begin, keyi-1] keyi [keyi+1, end]
	IntroSort(a, begin, keyi - 1, depth, defaultDepth);
	IntroSort(a, keyi + 1, end, depth, defaultDepth);
}

void QuickSort(int* a, int left, int right)
{
	int depth = 0;
	int logn = 0;
	int N = right - left + 1;
	for (int i = 1; i < N; i *= 2)
	{
		logn++;
	}

	// introspective sort -- ⾃省排序
	IntroSort(a, left, right, depth, logn * 2);
}

int* sortArray(int* nums, int numsSize, int* returnSize) 
{
	srand(time(0));
	QuickSort(nums, 0, numsSize - 1);
	*returnSize = numsSize;
	return nums;
}

总结

本篇博客系统性地剖析了快速排序的几种关键优化策略。首先探讨了Hoare和Lomuto的单趟排序技术，这两种方法通过独特的分区方式改善了算法在特定条件下的性能，并简化了实现逻辑。随后，我们详细讨论了三路划分算法，该算法通过将数组分为三部分来减少递归深度并优化处理各种数据分布的能力。这些深入的优化手段不仅在理论上增强快速排序的稳定性和效率，也极大地提升了其在实际应用场景中的可用性。希望读者能够通过本文，加深对快速排序及其优化方法的理解，并在未来的技术挑战中有效运用这些知识，以实现更高效的数据处理解决方案。