lcg_magic算法笔记：快速排序

---

1. 思想

快速排序是一种常用的排序方法。

快速排序的思想是：

• 首先在数组中选定一个参考值。
  这个参考值的作用是：将整个数组分成两个部分。小于这个参考值的所有值都在参考值的左边，大于这个参考值的所有值都在参考值的右边。
• 然后对小于参考值的部分和大于参考值的部分，分别使用相同的方法。直到这个部分无法再分为止。这就是快速排序的算法。

快速法排序参考值二分示意表

2. 示例

例子. 给定一个整型数组，使用快速法进行排序。默认是升序排序。

下面是原始的数据，共有10个元素。记为 ：

第一轮排序：

具体的可以参看文章基础算法-快速排序，更详细。

3. 代码

C++

​
#include <iostream>
using namespace std;

// 前向声明.
void quickSort(int *originalArray, int leftIndex, int rightIndex);

int main()
{
	// 整数的个数.
	int numbers = 0;
	cin >> numbers;

	// 保存整数的数组.
	int *originalData = new int[numbers];

	// 从标准输入中读取数据.
	for (int i = 0; i < numbers; ++i)
	{
		cin >> originalData[i];
	}

	// 对数据进行排序.
	// 使用二分排序法.
	quickSort(originalData, 0, numbers - 1);

	// 输出最小值和最大值.
	cout << originalData[0] << " " << originalData[numbers - 1] << endl;

	return 0;
}

void quickSort(int *originalArray, int leftIndex, int rightIndex)
{
	// leftIndex 的备份.
	int backLeft = leftIndex;

	// rightIndex 的备份.
	int backRight = rightIndex;

	// 递归结束条件.
	if (leftIndex > rightIndex)
	{
		// nothing to do.
	}
	else
	{
		// 参考标准.
		int standardValue = originalArray[leftIndex];

		while (leftIndex < rightIndex)
		{
			// 在 middleIndex 的右边部分,从后往前找到一个比 middleIndex 元素值小的元素.
			while (leftIndex < rightIndex)
			{
				if (originalArray[rightIndex] >= standardValue)
				{
					// next element.
					--rightIndex;
				}
				else
				{
					break;
				}
			}
			originalArray[leftIndex] = originalArray[rightIndex];
			
			// 在 middleIndex 的左边部分,从前往后找到一个比 middleIndex 元素值大的元素.
			while (leftIndex < rightIndex)
			{
				if (originalArray[leftIndex] <= standardValue)
				{
					// next element.
					++leftIndex;
				}
				else
				{
					break;
				}
			}
			originalArray[rightIndex] = originalArray[leftIndex];
		}

		// 保存标准值.
		originalArray[leftIndex] = standardValue;

		// 递归调用自身.
		quickSort(originalArray, backLeft, leftIndex - 1);
		quickSort(originalArray, leftIndex + 1, backRight);
	}
}

Java

​
import java.util.Arrays;
import java.util.Scanner;

public class QuickSort
{
	public static void main(String[] args)
	{
		Scanner scanner = new Scanner(System.in);

		int numbers = Integer.parseInt(scanner.nextLine());

		int[] originalArray = new int[numbers];
		for (int i = 0; i < numbers; ++i)
		{
			originalArray[i] = scanner.nextInt();
		}
		quickSort(originalArray, 0, numbers - 1);
		System.out.println(Arrays.toString(originalArray));
		scanner.close();
	}

	public static void quickSort(int[] originalData, int leftIndex, int rightIndex)
	{
		int backLeft = leftIndex;
		int backRight = rightIndex;
		if (leftIndex > rightIndex)
		{
			// nothing to do.
		}
		else
		{
			int standardValue = originalData[leftIndex];
			while (leftIndex < rightIndex)
			{
				while (leftIndex < rightIndex)
				{
					if (originalData[rightIndex] >= standardValue)
					{
						// next element.
						--rightIndex;
					}
					else
					{
						break;
					}
				}
				originalData[leftIndex] = originalData[rightIndex];

				while (leftIndex < rightIndex)
				{
					if (originalData[leftIndex] <= standardValue)
					{
						// next element.
						++leftIndex;
					}
					else
					{
						break;
					}
				}
				originalData[rightIndex] = originalData[leftIndex];
			}

			originalData[leftIndex] = standardValue;

			// 递归调用自身.
			quickSort(originalData, backLeft, leftIndex - 1);
			quickSort(originalData, leftIndex + 1, backRight);
		}
	}
}