【数据结构与算法】快速排序万字全攻略：hoare版本、挖坑法、前后指针法、优化版、非递归实现

倔强的石头_2025-06-18 12:30

​

目录

一、引言

历史背景

地位

二、快速排序的基本原理和实现

🍃hoare版本

🍃挖坑法

🍃前后指针法

三、快速排序的优化

🍃三数取中

🍃小区间优化

🍃加入三数取中和小区间优化后的版本

四、性能分析

[🍃时间复杂度：O(n log n)](#🍃时间复杂度：O(n log n) "#%F0%9F%8D%83%E5%88%9B%E5%BB%BA")

[🍃空间复杂度：O(log n)](#🍃空间复杂度：O(log n) "#%F0%9F%8D%83%E7%A9%BA%E9%97%B4%E5%A4%8D%E6%9D%82%E5%BA%A6%EF%BC%9AO(log%20n)")

🍃稳定性：不稳定

五、快速排序非递归实现

六、应用场景

一、引言

快速排序（Quick Sort）作为一种经典的排序算法，其历史背景和地位在计算机科学领域具有重要意义。

历史背景

1. 起源与提出

  • 时间：快速排序算法由C. A. R. Hoare（通常被称为Tony Hoare）在1960年提出，但也有说法认为是在1962年。这一算法最初在Hoare的论文"Quicksort"中进行了详细描述，该论文于1961年发表在《Computer Journal》上。
  • 背景：快速排序是对冒泡排序等简单排序算法的一种重大改进。冒泡排序虽然易于理解和实现，但其时间复杂度较高，达到了O(n^2)，这在处理大规模数据集时显得力不从心。因此，为了克服这一缺点，Hoare提出了快速排序算法。

2. 发展与优化

  • 优化策略：自快速排序提出以来，许多研究者对其进行了深入的研究和优化。这些优化策略包括但不限于：基准值的选择（如随机选择、三数中值分割等）、尾递归优化、小数组优化（当子数组较小时改用插入排序等更高效的算法）、并行快速排序等。
  • 广泛应用：随着计算机科学的不断发展，快速排序算法得到了广泛的应用。它不仅在数据排序中发挥着重要作用，还被应用于数据库管理、文件排序、数据分析等多个领域。

地位

1. 经典算法之一

  • 快速排序是计算机科学中最著名的排序算法之一，与归并排序、堆排序等算法齐名。它以其简洁的算法逻辑和高效的性能表现，成为了排序算法中的佼佼者。

2. 广泛使用

  • 快速排序在实际应用中具有广泛的适用性。无论是编程语言的标准库（如Python的sorted函数、Java的Arrays.sort方法等）还是各种数据处理系统（如数据库管理系统、数据分析工具等），都广泛采用了快速排序算法或其变种。

3. 面试与竞赛常见

  • 由于快速排序算法的重要性，它经常出现在各种编程面试和算法竞赛中。掌握快速排序算法的原理和实现方式，对于提高编程能力和应对面试、竞赛等挑战具有重要意义。

二、快速排序的基本原理和实现

🍃hoare版本

基本原理

​编辑

实现思路：

  1. 递归终止条件 ：首先检查left（左边界）是否大于等于right（右边界），如果是，则说明当前子数组的长度小于或等于1，此时不需要排序，直接返回。

  2. 选择基准值 ：这里选择子数组的第一个元素a[left]作为基准值（keyi），并将keyi的索引保存在keyi变量中。

  3. 分区操作：

    • 使用两个指针begin和end，分别从数组的左右两端开始扫描。
    • end指针从右向左移动，直到找到一个小于或等于基准值的元素。
    • 同时，begin指针从左向右移动，直到找到一个大于基准值的元素。
    • 如果begin和end没有相遇（即begin < end），则交换a[begin]和a[end]的值，然后继续移动指针。
    • 这个过程会一直进行，直到begin和end相遇或交错。
    • 当begin和end相遇时，将基准值（即a[keyi]）与a[begin]（此时begin == end）交换，这样基准值就被放到了它最终应该在的位置。

  4. 递归排序：

    • 更新keyi的值为begin（即基准值最终所在的位置）。
    • 然后，对基准值左边的子数组（left到keyi-1）和右边的子数组（keyi+1到right）分别递归调用Quicksort1函数进行排序。

优势与特点：

  • Hoare版本的快速排序在分区时，begin和end指针是同时从数组的两端向中间移动，这有助于减少数据移动的次数，尤其是在数组已经部分有序的情况下。
  • 该算法的时间复杂度平均为O(n log n)，但在最坏情况下（如数组已经有序或逆序）会退化到O(n^2)。为了改善最坏情况的表现，可以参考本文后面的优化策略。

注意：在实际应用中，快速排序的性能很大程度上取决于基准值的选择和分区策略。Hoare版本的分区策略相对简单，但在某些情况下可能不是最优的。

C语言实现代码

arduino 复制代码 
void Swap(int* a, int* b)//交换函数
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
// 快速排序hoare版本
void  Quicksort1(int* a, int left, int right)
{
	if (left >= right)//只有一个元素或不存在，停止递归
		return ;

	int keyi = left;
	int begin = left, end = right;

	while (begin < end)//begin与end未相遇时，继续循环
	{
		while (begin < end && a[end] >= a[keyi])//end先移动，找到小于keyi位置的值停止
			end--;
		while (begin < end && a[begin] <= a[keyi])//begin再移动，找到大于keyi位置的值停止
			begin++;
		Swap(&a[begin], &a[end]);
	}
	Swap(&a[keyi], &a[begin]);//出循环后，begin与end相遇，交换此位置与keyi位置的值

	keyi = begin;//更新keyi的位置
	//[left][keyi-1]keyi[keyi+1][right]  左右区间划分
	Quicksort1(a, left, keyi - 1);//左区间递归
	Quicksort1(a, keyi + 1, right);//右区间递归
}

🍃挖坑法

基本原理

​编辑

实现思路：

  1. 终止条件 ：首先检查left（左边界）是否大于等于right（右边界），如果是，则当前子数组的长度小于或等于1，不需要排序，直接返回。

  2. 选择基准值 ：选择子数组的第一个元素a[left]作为基准值，并将其存储在临时变量tmp中。这里的tmp用于后续将基准值放回到其在排序后数组中的正确位置。

  3. 分区操作（挖坑法）：

    • 使用两个指针begin和end，分别初始化为left和right。这两个指针用于从数组的两端开始向中间扫描。
    • end指针从右向左移动，寻找第一个小于基准值tmp的元素。找到后，将该元素的值放到begin指针所指的"坑"中（如果begin和end没有相遇）。
    • 然后，begin指针从左向右移动，寻找第一个大于基准值tmp的元素。找到后，将该元素的值放到end指针所指的"坑"中（注意，此时end已经向左移动过，所以不会覆盖之前放置的值）。
    • 这个过程会一直进行，直到begin和end相遇或交错。此时，begin（或end，因为它们相遇了）所在的位置就是基准值tmp应该放置的位置。

  4. 放置基准值 ：将保存在tmp中的基准值放到begin（或end，它们现在相同）所指的位置。这个位置就是基准值在排序后数组中的正确位置。

  5. 递归排序：

    • 现在，基准值已经处于其最终位置，我们可以将数组分为左右两个子数组进行递归排序。
    • 左子数组的范围是从left到keyi - 1（因为keyi现在是基准值的正确位置）。
    • 右子数组的范围是从keyi + 1到right。

优势与特点：

  • 挖坑法的特点是它始终将基准值（在这个例子中是tmp）保留在外部变量中，直到分区操作完成后再将其放回到数组中。这种方法简化了分区过程中元素的交换逻辑，但可能需要额外的空间来存储基准值。不过，在这个特定的实现中，基准值是从数组中直接取出的，所以并没有额外的空间开销。

C语言实现代码

sql 复制代码 
void Quicksort2(int* a, int left, int right)
{
	if (left >= right)//只有一个元素或不存在，停止递归
		return;
	int tmp = a[left];//先将基准值存下来
	int keyi = left;
	int begin = left, end = right;
	while (begin < end)
	{
		while (begin < end && a[end] <= tmp)//右找大，找到停下来，填到左边的坑
			end--;
		if(begin<end)
			a[begin] = a[end];
		
		while (begin < end && a[begin] >= tmp)//左找小，找到停下来，填到右边的坑
			begin++;
		if(begin<end)
			a[end] = a[begin];
	}
	a[begin] = tmp;//相遇之后，将保存的值填到相遇位置

	keyi = begin;
	Quicksort2(a, left, keyi - 1);
	Quicksort2(a, keyi + 1, right);

}

🍃前后指针法

基本原理

​编辑

实现思路：

  1. 终止条件 ：首先检查left（左边界）是否大于等于right（右边界），如果是，则当前子数组的长度小于或等于1，不需要排序，直接返回。

  2. 选择基准值 ：选择子数组的第一个元素a[left]作为基准值，并将该位置的索引存储在keyi变量中。虽然这个索引在后续操作中没有被直接用于交换，但它用于在分区结束后确定基准值的最终位置。

  3. 初始化指针：

    • prev（前指针）初始化为left，它用于记录小于基准值的最后一个元素的位置。
    • cur（后指针）初始化为left + 1，它用于遍历数组中的元素，寻找小于基准值的元素。

  4. 分区操作：

    • 使用while循环，当cur小于等于right时执行循环体。
    • 在循环体内，如果a[cur]小于基准值a[keyi]，并且prev没有指向当前cur的位置（即prev++ != cur，这是为了避免自身与自身的无用交换），则将a[prev]和a[cur]的值交换。然后，prev向前移动一步（prev++在条件判断之后执行，确保只有在需要时才进行交换和移动）。
    • cur始终向前移动，直到遍历完整个子数组。

  5. 放置基准值：

    • 当cur遍历完整个子数组后，循环结束。此时，prev指向的是最后一个小于基准值的元素的位置（注意，如果所有元素都大于等于基准值，则prev将停留在left位置）。
    • 将基准值a[keyi]与a[prev]交换，这样基准值就被放到了它最终应该在的位置。

  6. 更新基准值位置：

    • 由于基准值已经与a[prev]交换，所以将keyi更新为prev，以反映基准值的新位置。

  7. 递归排序：

    • 对基准值左边的子数组（left到keyi - 1）和右边的子数组（keyi + 1到right）分别递归调用Quicksort3函数进行排序。

优势与特点：

  • 代码实现相对简洁，与其他版本相比，代码更不容易出错，边界控制也更为容易
  • 与hoare版本相同，一般情况下会多出一些数据交换（因为较大的数据不是直接移动到该在的位置），但最终效率影响不大

C语言实现代码

ini 复制代码 
void Swap(int* a, int* b)//交换函数
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void Quicksort3(int* a, int left, int right)
{
	if (left >= right)//只有一个元素或不存在，停止递归
		return;
	int keyi = left;

	int prev = left;//前指针
	int cur = left + 1;//后指针
	while (cur <= right)//cur越界结束循环
	{
		//cur一直向后走，遇到小的值就停下，让prev向前走一步并交换
		if (a[cur] < a[keyi] && prev++ != cur)//prev++ != cur是为了避免无用的原地交换
			Swap(&a[prev], &a[cur]);
		cur++;
	}
	Swap(&a[keyi], &a[prev]);//出循环，将prev停留位置与keyi位置进行交换

	keyi = prev;
	Quicksort3(a, left, keyi - 1);
	Quicksort3(a, keyi + 1, right);
}

三、快速排序的优化

🍃三数取中

上述快速排序实现代码在最坏情况下（如数组已经有序或逆序）会退化到O(n^2)。为了改善最坏情况的表现，可以采取三数取中法来优化。

快速排序三数取中法（也称为三数中值分割法）是快速排序算法的一种优化策略，它旨在通过更合理地选择分区点来减少算法在极端情况下的性能退化。

思想：

三数取中优化的主要目的是减少在数组已经部分有序或几乎有序时，由于分区点（pivot）选择不当而导致的性能退化。在极端情况下，如果分区点总是选择到数组的最小值或最大值，那么每次分区都将导致一个空子数组和一个几乎不变的子数组，从而使得算法的时间复杂度退化为O(n^2)。

实现 ：

通过比较数组左端点（left）、中间点（mid）和右端点（right）的值，选择这三个数中的中间值作为分区点。将中间值交换为数组的左端点（left），原代码的逻辑依然不变

🍃小区间优化

目的 ：
小区间优化是为了处理快速排序在处理小规模数组时可能不如其他排序算法（如插入排序）高效的问题。当数组规模较小时，快速排序的递归调用和分区操作可能会带来较大的开销，比如区间只剩几个元素时仍然需要递归调用，建立栈帧，而使用插入排序在这些情况下通常能提供更好的性能。

实现 ：

在QuickSort1函数中，通过检查区间长度（right - left + 1），如果它小于某个阈值（比如10），则停止递归，转而调用插入函数对该小区间进行插入排序。这是一种常见的混合排序策略，旨在结合不同排序算法的优势。

附：插入排序参考文章

【数据结构与算法】插入排序：原理、实现与分析在众多排序算法中，插入排序作为一种简单直观的排序方法，虽然在大规模数据集上可 - 掘金

🍃加入三数取中和小区间优化后的版本

Hoare版本

css 复制代码 
void Swap(int* a, int* b)//交换函数
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void InsertSort1(int* a, int n)//插入排序升序
{
	for (int i = 1; i <= n-1 ; i++)//控制要插入的元素个数
	{
		int key = a[i];
		int end = i - 1;
		while (end >= 0 && a[end] > key)//移动元素
		{
			a[end + 1] = a[end];
			end--;
		}
		a[end+1] = key;//满足大小关系后插入到指定位置
	}
}
int GetMid(int* a,int left,int right)//三数取中函数
{
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])//说明a[left] > a[mid] > a[right]
			return mid;
		//走到这里说明a[mid]是最小值
		else if (a[left] > a[right])
			return right;
		else
			return left;
	}
	else	//走到这里说明a[left] < a[mid]
	{
		if (a[left] > a[right])//说明a[mid] > a[left] > a[right]
			return left;
		//走到这里说明a[left]是最小值
		else if (a[mid] > a[right])
			return right;
		else
			return mid;
	}

}
void QuickSort1(int* a, int left, int right)//优化
{
	if (left >= right)//只有一个元素或不存在，停止递归
		return;
	if ((right - left+1) < 10)//如果区间小于10，停止递归，改用直接插入排序
		InsertSort1(a+left, right-left+1);//参数分别是区间起始地址，和区间元素个数
	else
	{
		int midi = GetMid(a, left, right);//三个数取中间值的下标
		Swap(&a[left], &a[midi]);
		int keyi = left;
		int begin = left, end = right;

		while (begin < end)//begin与end未相遇时，继续循环
		{
			while (begin < end && a[end] >= a[keyi])//end先移动，找到小于keyi位置的值停止
				end--;
			while (begin < end && a[begin] <= a[keyi])//begin再移动，找到大于keyi位置的值停止
				begin++;
			Swap(&a[begin], &a[end]);
		}
		Swap(&a[keyi], &a[begin]);//出循环后，begin与end相遇，交换此位置与keyi位置的值

		keyi = begin;//更新keyi的位置
		//[left][keyi-1]keyi[keyi+1][right]  左右区间划分
		QuickSort1(a, left, keyi - 1);//左区间递归
		QuickSort1(a, keyi + 1, right);//右区间递归
	}
}

挖坑法

css 复制代码 
void Swap(int* a, int* b)//交换函数
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void InsertSort1(int* a, int n)//插入排序升序
{
	for (int i = 1; i <= n-1 ; i++)//控制要插入的元素个数
	{
		int key = a[i];
		int end = i - 1;
		while (end >= 0 && a[end] > key)//移动元素
		{
			a[end + 1] = a[end];
			end--;
		}
		a[end+1] = key;//满足大小关系后插入到指定位置
	}
}
int GetMid(int* a,int left,int right)//三数取中函数
{
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])//说明a[left] > a[mid] > a[right]
			return mid;
		//走到这里说明a[mid]是最小值
		else if (a[left] > a[right])
			return right;
		else
			return left;
	}
	else	//走到这里说明a[left] < a[mid]
	{
		if (a[left] > a[right])//说明a[mid] > a[left] > a[right]
			return left;
		//走到这里说明a[left]是最小值
		else if (a[mid] > a[right])
			return right;
		else
			return mid;
	}

}
void QuickSort2(int* a, int left, int right)
{
	if (left >= right)//只有一个元素或不存在，停止递归
		return;
	if ((right - left + 1) < 10)//如果区间小于10，停止递归，改用直接插入排序
		InsertSort1(a + left, right - left + 1);//参数分别是区间起始地址，和区间元素个数
	else
	{
		int midi = GetMid(a, left, right);//三个数取中间值的下标
		Swap(&a[left], &a[midi]);
		
		int tmp = a[left];//先将基准值存下来
		int keyi = left;
		int begin = left, end = right;
		while (begin < end)
		{
			while (begin < end && a[end] <= tmp)//右找大，找到停下来，填到左边的坑
				end--;
			if (begin < end)
				a[begin] = a[end];

			while (begin < end && a[begin] >= tmp)//左找小，找到停下来，填到右边的坑
				begin++;
			if (begin < end)
				a[end] = a[begin];
		}
		a[begin] = tmp;//相遇之后，将保存的值填到相遇位置

		keyi = begin;
		Quicksort2(a, left, keyi - 1);
		Quicksort2(a, keyi + 1, right);
	}
	
}

前后指针法

css 复制代码 
void Swap(int* a, int* b)//交换函数
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void InsertSort1(int* a, int n)//插入排序升序
{
	for (int i = 1; i <= n-1 ; i++)//控制要插入的元素个数
	{
		int key = a[i];
		int end = i - 1;
		while (end >= 0 && a[end] > key)//移动元素
		{
			a[end + 1] = a[end];
			end--;
		}
		a[end+1] = key;//满足大小关系后插入到指定位置
	}
}
int GetMid(int* a,int left,int right)//三数取中函数
{
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])//说明a[left] > a[mid] > a[right]
			return mid;
		//走到这里说明a[mid]是最小值
		else if (a[left] > a[right])
			return right;
		else
			return left;
	}
	else	//走到这里说明a[left] < a[mid]
	{
		if (a[left] > a[right])//说明a[mid] > a[left] > a[right]
			return left;
		//走到这里说明a[left]是最小值
		else if (a[mid] > a[right])
			return right;
		else
			return mid;
	}

}
void QuickSort3(int* a, int left, int right)
{

	if (left >= right)//只有一个元素或不存在，停止递归
		return;
	if ((right - left + 1) < 10)//如果区间小于10，停止递归，改用直接插入排序
		InsertSort1(a + left, right - left + 1);//参数分别是区间起始地址，和区间元素个数
	else
	{
		int midi = GetMid(a, left, right);//三个数取中间值的下标
		Swap(&a[left], &a[midi]);
		int keyi = left;
		int prev = left;//前指针
		int cur = left + 1;//后指针
		while (cur <= right)//cur越界结束循环
		{
			//cur一直向后走，遇到小的值就停下，让prev向前走一步并交换
			if (a[cur] < a[keyi] && prev++ != cur)//prev++ != cur是为了避免无用的原地交换
				Swap(&a[prev], &a[cur]);
			cur++;
		}
		Swap(&a[keyi], &a[prev]);//出循环，将prev停留位置与keyi位置进行交换

		keyi = prev;
		Quicksort3(a, left, keyi - 1);
		Quicksort3(a, keyi + 1, right);
	}
}

四、性能分析

🍃时间复杂度：O(n log n)

  1. 最好情况（O(n log n)） ：

    当每次分区操作都能将数组分为两个大致相等的部分时，快速排序的性能最好。这种情况下，算法的时间复杂度为O(n log n)，其中n是数组的长度。这是因为每次分区后，问题规模减半，形成一棵深度为log n的平衡二叉树。

  2. 最坏情况（O(n^2)） ：

    当数组已经有序或几乎有序，且分区点总是选择到数组的最小值或最大值时，快速排序的性能会退化到O(n^2)。这是因为每次分区操作都会将一个元素（分区点）放到其最终位置，而另一个子数组保持不变，导致算法需要进行n-1次分区操作。

  3. 平均情况（O(n log n)） ：

    对于随机排列的数组，快速排序的平均时间复杂度也是O(n log n)。虽然存在最坏情况的风险，但通过随机选择分区点或使用三数取中等策略，可以大大降低遇到最坏情况的可能性。

🍃空间复杂度：O(log n)

  • 递归栈空间（O(log n) 到 O(n)） ：
    快速排序是递归的，因此需要使用系统栈来保存递归调用的状态。在最好情况下，递归深度为log n（平衡二叉树），但在最坏情况下，递归深度为n（链表结构）。不过，经过上述优化之后，最坏情况一般不会出现。

🍃稳定性：不稳定

  • 快速排序不是一种稳定的排序算法。在排序过程中，相等元素的相对顺序可能会发生变化。如果需要稳定性，可以考虑使用归并排序等其他排序算法。

五、快速排序非递归实现

基本思路

通过迭代的方式实现快速排序，但实现过程中结合了递归快速排序的思想，并使用了一个栈（Stack）来模拟递归调用的栈行为。这种做法的主要目的是避免直接使用递归，从而在某些栈空间有限的环境下减少栈溢出的风险。

迭代实现的基本思路

由于递归实现中，每次递归调用都会将数组的一个子区间（left, right）作为新的排序区间，因此迭代实现中需要使用一个栈来模拟这一过程。具体步骤如下：

  • 初始化栈：使用一个栈来存储待排序的区间，初始时将整个数组区间（left, right）压入栈中。
  • 循环处理栈：只要栈不为空，就不断从栈中取出区间（left, right），对这个区间进行快速排序处理（即选择基准值，进行分区），然后可能得到两个新的子区间（如果子区间长度大于1）。
  • 子区间入栈：将得到的两个子区间（如果有的话）重新压入栈中，以便后续继续处理。
  • 重复处理：重复上述过程，直到栈为空，此时所有区间都已处理完成，整个数组排序也就完成了。

代码实现中的关键点

  • Quicksort 函数：这个函数实际上执行的是快速排序的分区操作，并返回基准值的最终位置。它负责将数组分为两部分，并返回这两部分的分界线（即基准值的最终位置）。
  • QuickSortNonR 函数：这个函数是迭代快速排序的主函数，它使用栈来模拟递归过程。它首先初始化栈，并将整个数组的区间压入栈中，然后不断从栈中取出区间进行处理，并将新的子区间压回栈中，直到栈为空。
  • 栈操作 ：代码中使用了自定义的栈结构（Stack），包括初始化（StackInit）、入栈（StackPush）、出栈（StackPop）、判断栈空（StackEmpty）、栈顶元素（StackTop）和销毁栈（StackDestroy）等操作。

C语言实现代码

CV了之前已经实现好的栈的代码

参考文章

【数据结构与算法】探索数组在堆数据结构中的妙用：从原理到实现堆是一种特殊的树形数据结构，其每个节点的值都大于或等于（大顶 - 掘金

scss 复制代码 
void Swap(int* a, int* b)//交换函数
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
int  Quicksort(int* a, int left, int right)//快排hoare版子函数
{
	int midi = GetMid(a, left, right);//三个数取中间值的下标
	Swap(&a[left], &a[midi]);
	int keyi = left;
	int begin = left, end = right;

	while (begin < end)//begin与end未相遇时，继续循环
	{
		while (begin < end && a[end] >= a[keyi])//end先移动，找到小于keyi位置的值停止
			end--;
		while (begin < end && a[begin] <= a[keyi])//begin再移动，找到大于keyi位置的值停止
			begin++;
		Swap(&a[begin], &a[end]);
	}
	Swap(&a[keyi], &a[begin]);//出循环后，begin与end相遇，交换此位置与keyi位置的值
	keyi = begin;
	return keyi;
}
void QuickSortNonR(int* a, int left, int right)
{
	//创建栈并初始化
	Stack SK;
	StackInit(&SK);

	//右左区间入栈
	StackPush(&SK, right);
	StackPush(&SK, left);

	while (!StackEmpty(&SK))//栈不为空，继续排序
	{
		int begin = StackTop(&SK);//取一组左右区间并出栈
		StackPop(&SK);
		int end = StackTop(&SK);
		StackPop(&SK);

		int keyi = Quicksort(a, begin, end);//调用快排hoare子函数

		if ((keyi + 1) < end)//如果右区间>1,入栈
		{
			StackPush(&SK, end);
			StackPush(&SK, keyi + 1);
		}
		if (begin < (keyi - 1))//如果左区间>1,入栈
		{
			StackPush(&SK, keyi - 1);
			StackPush(&SK, begin);
		}
	}
	StackDestroy(&SK);//排序完成，销毁栈
}

六、应用场景

  1. 大数据排序：当需要处理大量数据时，快速排序能够高效地完成任务。由于它使用递归分治策略，因此能够很好地适应大数据集。

  2. 文件排序：在需要按某种顺序处理文件中的记录时，快速排序可用于将文件内容排序。这对于数据库管理和文件索引尤其重要。

  3. 内存数据库：在内存数据库中，数据通常存储在RAM中，以便快速访问。快速排序算法因其速度快，非常适合用于内存数据库中对数据进行排序。

  4. 搜索引擎：搜索引擎在处理查询时，可能需要按相关度或其他指标对搜索结果进行排序。快速排序可以帮助搜索引擎快速地对大量搜索结果进行排序。

  5. 实时数据处理：在需要实时处理大量数据的系统中（如实时分析、实时监控系统等），快速排序算法因其高效性而被广泛使用。

  6. 编程竞赛和算法学习：由于快速排序算法是计算机科学中的经典算法之一，因此在编程竞赛和算法学习中经常被用作练习和评估学生或参赛者算法理解和实现能力的工具。

  7. 操作系统：在操作系统的某些部分，如文件系统的元数据管理、进程调度等，可能需要对数据结构进行排序。快速排序因其高效性和稳定性，在这些场景中也有应用。

  8. 图形和图像处理：在图形和图像处理领域，有时需要对像素、颜色或其他图像属性进行排序，以便进行进一步处理或分析。快速排序算法可以用于这些任务。

本文完

​

相关推荐
没故事的燕同学8 分钟前
[GESP202306 三级] 密码合规
算法
惜鸟11 分钟前
Spring Boot项目自己封装一个分页查询工具
spring boot·后端
Dithyrambus12 分钟前
ObjectScript 中文入门教程
后端
钢铁男儿34 分钟前
C#数组完全指南：从基础到多维数组解析
数据结构·算法
林太白37 分钟前
也许看了Electron你会理解Tauri,扩宽你的技术栈
前端·后端·electron
松果集43 分钟前
【Python3】练习一
后端
anganing43 分钟前
Web 浏览器预览 Excel 及打印
前端·后端
肯定慧1 小时前
B1-基于大模型的智能办公应用软件
后端
豆沙沙包?1 小时前
2025年- H82-Lc190--322.零钱兑换(动态规划）--Java版
java·算法·动态规划
热门推荐
01扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解02Coze扣子平台完整体验和实践（附国内和国际版对比）03KGG转MP3工具|非KGM文件|解密音频04DeepSeek各版本说明与优缺点分析05零代码入门 | Coze——让大模型接入自己的数据库06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07AI Agent | Coze 插件使用指南：从功能解析到实操步骤08扣子空间的使用教程与大模型技术思考09YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】10ADS仿真低噪声放大器学习笔记