lcg_magic算法笔记:快速排序

文章目录

  • 1. 思想
  • 2. 示例
  • 3. 代码


1. 思想

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

快速排序的思想是:

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

快速法排序参考值二分示意表
lcg_magic算法笔记:快速排序_第1张图片

2. 示例

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

下面是原始的数据,共有10个元素。记为 :
lcg_magic算法笔记:快速排序_第2张图片

第一轮排序:
lcg_magic算法笔记:快速排序_第3张图片

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

3. 代码

C++

#include 
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);
		}
	}
}

你可能感兴趣的:(#,Algorithms,快速排序,Java,C++,算法)