【C++】快速排序的学习和介绍

前言

本篇文章我们先会学习快速排序这个算法，之后我们会学习sort这个函数

分治算法

在学习快速排序之前，我们先来学习一下分治算法，快速排序就是分治算法的一种，下面是分治算法的介绍，

分治算法，就是”分而治之“

分为分解、治理和合并这三个步骤
后面我们学习快速排序也是从这三个步骤入手

简单来说，分治算法就是将一个大问题分解成许多小的问题，
又因为这些小的问题的解决方案与大问题相同，只是规模更小而已
所以当子问题划分得足够小时，就可以用很简单的方法来解决原本看起来很复杂的大问题。

通过上面的学习，我们可以看出，快速排序就是分治算法中的一种

快速排序算法（可优化版本）

基本步骤

分解

首先将数组中的一个元素作为pivot（轴点 / 基准点，可以理解为分界点）

之后从最左侧的元素和最右侧的元素开始遍历，比轴点大的放到最右侧，比轴点小的就放到最左侧

对于轴点的选择

我们可以选择数组首元素作为轴点，或者最后一个元素，又或者是数组中的任意一个元素

治理

一次排序完成后，分别对轴点左侧和右侧的剩余元素进行排序（使用递归重复上面的步骤）

合并

将最终排序好的各个子串合并到一起，就实现了快速排序这个算法

基本思想就是这样，下面，让我们来逐步实现

分步实现

排序一次

首先以首元素作为基准点（一般都是第一个元素），赋值给pivot变量，数组最左侧元素下标赋值给left变量，最右侧下标赋值给right这个变量

然后，从右向左开始逐个与轴点比较，当其小于轴点时，将这个元素与这个串中left下标指向的元素位置互换，left向右移动一位

然后，从左向右开始逐个与轴点比较，当其大于轴点时，将这个元素与这个串中right指向的那个元素互换，right向左移动一位

重复二三步，直到left与right重合，一次排序完成

对分割后的子串进行排序

排序完一次之后，轴点左侧的元素比轴点小，右侧的元素比轴点大，

之后，分别对左侧的子串和右侧的子串进行排序，

此处需要使用递归，直到传入的参数：left==right时，开始回归，又因为函数返回类型是void，那么也就可以理解为函数调用结束，数组排序完成

例子图解

下面，通过对一个数组进行排序，来更生动的去学习这个算法

以数组6 1 2 7 9 3 4 5 10 8为例

下面只解释第一次排序的过程

选取轴点

首先，选取首元素6，作为轴点，进行第一次排序，如图所示

从右向左开始排序

从8开始向左逐个查找，查找到5的时候，发现5比轴点小，那么就将5这个元素与轴点（也就是left下标指向的元素）互换，left++，向右移动一位（跳过已经排序完的元素），right变为轴点所在的下标

如图：

从右向左排序

从left所指向的元素开始与轴点比较，当遇到比轴点大的就与轴点互换，然后right–，向左移动一位（跳过已经排序完的元素），left变为轴点所在的下标

继续排序

重复以上两步：先从右侧开始向左查找，替换、再从左向右开始查找，替换

当left和right重合时，说明本次查找完成

递归查找剩下的子串

通过上面的学习，我们可以知道，对与一个串的排序，其基本操作是一样的，只不过规模大小不同罢了，这就是分治算法中提到的分解与治理

代码实现

基本步骤和具体思路都介绍完了，剩下的就是通过代码去实现它了

函数主体

int main()
{
	int a[10001];
	int N;
	cout << "请输入要排序的元素个数" << endl;
	cin >> N;
	cout << "请输入要排序的元素" << endl;
	for (int i = 0; i < N; i++)
	{
		cin >> a[i];
	}

	cout << endl;//可有可无，此处换行只是为了美观

	Quicksort(a, 0, N - 1);
	cout << "排序后的数组结果" << endl;
	for (int i = 0; i < N; i++)
	{
		cout << a[i] << " ";//这里输入一个空格也是为了美观，方便阅读
	}
	cout << endl;
	return 0;
}

Quicksort函数就是实现递归排序的函数

Quicksort函数

void Quicksort(int* r, int left, int right)
{
	int mid = 0;
	if (left < right)
	{
		mid = part(r, left, right);
		Quicksort(r, left, mid - 1);
		Quicksort(r, mid + 1, right);
	}
}

part函数是实现一次排序的函数

part函数

part函数是实现一次排序的函数，并且part函数返回的是一次排序完成后的新的基准值（就是left和right下标重合的位置）

int part(int* r, int left, int right)
{
	int i = left;
	int j = right;
	int pivot = r[left];//选择首元素作为基准点
	while (i < j)
	{
		while (i<j && r[j]>pivot)//从右向左查找小于基准点的元素
		{
			j--;
		}
		if (i < j)
		{
			swap(r[i++], r[j]);//交换基准点和left下标的元素，并且left下标向右移动一位
		}
		while (i < j && r[i] <= pivot)//从左向右查找大于基准点的元素
		{
			i++;
		}
		if (i < j)
		{
			swap(r[i], r[j--]);交换基准点和right下标的元素，并且right下标向左移动一位
		}
		return i;
		//返回的是最终划分完成后人（即left和right重合）的新的基准点，
		//作为字串的left或right的下标
	}

}

swap函数

在part函数中，为了更快捷的将两个元素互换，我们使用到了swap函数，下面，就对swap函数做一个简单的介绍

swap(a, b);

这个函数很厉害，
它不仅可以交换整型、浮点型
它还可以交换结构体（当然，成员个数得一样）

下面给一个交换结构体的例子

#include
#include
#include//sort函数包含的头文件
using namespace std;
//定义一个学生类型的结构体
typedef struct student
{
    string name;           //学生姓名
     int achievement;     //学生成绩
} student;


 //用来显示学生信息的函数
void show(student * stu, int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << "姓名:" << stu[i].name << '\t' << "成绩:" << stu[i].achievement << endl;
	}
}

int main()
{
     student stu1[] = { {"李四",87},{"王二",100} };
     student stu2[] = { {"22",2},{"33",3} };
     cout << "交换前：" << endl;
     show(stu1, 3);
     show(stu2, 3);
     swap(stu1, stu2);
     cout << "交换后：" << endl;
     show(stu1, 3);
     show(stu2, 3);

     return 0;
}

并且，使用swap函数，不用担心精度的损失

补充说明

对于排序方式的解释

对于为什么要先从右向左开始查找，同学们可能会有疑惑，那么我们不妨试一试先从左向右查找，看看结果如何

还是以“6 1 2 7 9 3 4 5 10 8”这个数组为例子

第一次排序时：
我们先让left从左边开始，遇到小于等于6的继续走，大于6的停下，于是left停在了7的位置；
再让right从右边走，小于6的时候停下，于是right停在5的位置；
这个时候left < right
于是7和5交换位置变成“6 1 2 5 9 3 4 7 10 8”；
继续上面的操作，9和4交换，变成“6 1 2 5 4 3 9 7 10 8”，继续，left先移动，停在了9的位置，这个时候left == right了，那么这一轮就比较完了，最后需要交换left和pivot位置的数（基准数归位），

这个时候，6与9交换，变成了下面的序列：“9 1 2 5 4 3 6 7 10 8”，
这个序列并不是完成了一轮处理之后，基准数左边的都比基准数小，右边的都比它大。所以这样先从左边开始搜索得不到正确结果的。

因此，我们可以得到下面的结论：当基准数选择最左边的数字时，那么就应该先从右边开始搜索；当基准数选择最右边的数字时，那么就应该先从左边开始搜索。不论是从小到大排序还是从大到小排序！

快速排序的优化

其实，我们不需要每次遇到比轴点大 / 比轴点小的元素就与轴点进行交换，可以直接将这两个元素交换，再移动left与right直到二者相等，这就完成了一次排序
再将轴点更新为left下标所在的位置，进行递归排序

至于具体的代码，我还没想明白，在此只是提出这个思路，之后再去实现

快速排序与冒泡排序

冒泡排序我们都知道，这里就不再重复叙述

快速排序与冒泡排序相比，快速排序的优点是

快速排序的每次交换是跳跃式的，就是距离很大

当轴点左侧的元素大于轴点时，会被直接放到右侧right指针所指向的位置，这样交换时跨越的距离是很大的，

而冒泡排序，每次只能是相邻的两个元素进行比较，这样就比较低效了

结语

关于快速排序这个算法知识就介绍到这里了，希望大家都有所收获，我们下篇文章见~