算法中最常用---排序（一）（让你不再害怕面试官提问）

write in front

作者：@ 不进大厂不改名
专栏：@ 算法
作者简介：大一学生 希望能向其他大佬和同学学习，作者将在这开启算法专栏，和大家一起去学习和了解一般的算法。
本篇博客简介：这里将用最通俗易懂的方法让你了解排序算法（文章里附有许多插图，方便理解）。

本章目标

1.计数排序 - - -“最快最简单的排序”
2.冒泡排序- - -“思想最简单的排序”
3.快速排序- - -“最常用的排序”

1.计数排序

桶排序的概念

计数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)(其中k是整数的范围)，快于任何比较排序算法。 当然这是一种牺牲空间换取时间的做法，O(k)>O(n*log(n))的时候其效率反而不如基于比较的排序(基于比较的排序的时间复杂度在理论上的下限是O(n*log(n)), 如归并排序，堆排序)。

不要被上面一串概念给难住了，因为它的实现其实非常简单，下面我们用一个简单的例子进行引入。

假如期末考试考完了，老师要将同学们的成绩进行排序，小明的的班上一共有5个同学，他们分别考了5分，3分，2分，8分，9分，考得真是惨！其实满分是（10分） 你有没有好的办法编一个程序，将他们从大到小(或者从小到大)进行排序呢？(至少要想上10分钟再往下看。)

在这里其实上借助一个一维数组就可以解决这个问题。
首先我们先分析一下，最高分是9分，最低分是2分，数字都在（2~9）之间，所以我们只要建立一个大小为8的数组int a[8]就行了。（9-2+1=8）
这时候的数组最多能存下8个数，我们先把它里面的所有值都初始化为0，表示这些分数都没有人得过，例如a[0]=0，就表示2分（最少分，后面再解释）没有人得过。

这里有一个很重要的一点是找到最多分和最少分（这样能减少开辟的空间）。这里的最多分是9，最少分是2。（第一步）
下面进行数据的处理，第一个人得了5分，那么就在a[5-2]原来的基础上加1就行了，接着是3分，就在a[3-2]的基础上加1就行了。以此类推，实际上就是每个分数要存在该分数-最少分的空间里面。

a[0]=1,表示“0+2”出现过1次，进行打印。
a[1]=1,表示“1+2”出现过1次，进行打印
a[2]=1,表示“2+2”出现过0次，不进行打印
a[3]=1,表示“3+2”出现过1次，进行打印
a[4]=1,表示“4+2”出现过0次，不进行打印
a[5]=1,表示“5+2”出现过0次，不进行打印
a[6]=1,表示“6+2”出现过1次，进行打印
a[7]=1,表示“7+2”出现过1次，进行打印
要打印的分数和下标的关系是分数=下标+最少分数就行。
最后打印的数字就是2 3 5 8 9

代码如下：

#include <iostream>
using namespace std;
int main()
{
	int b[5] = { 5,3,2,8,9 };
	int min =b[0], max =b[0];
	for (int i = 0; i < 5; i++)
	{
		if (b[i] < min)
		{
			min = b[i];
		}
	}
	for (int i = 0; i < 5; i++)
	{
		if (b[i] > max)
		{
			max= b[i];
		}
	}
	int range = max - min + 1;
	int* a = (int*)malloc(sizeof(int) * range);
	memset(a, 0, sizeof(int) * range);
	for (int i = 0; i < 5; i++)
	{
		a[b[i] - min]++;
	}
	for (int i = 0; i < 8; i++)
	{
		for (int j = 0; j <a[i]; j++)
		{
			printf("%d ", i + min);
		}
	}
	
}

看一下运行结果

如果要进行降序呢？（这里可以先想一想）

for (int i = range-1; i>=0 ; i--)
	{
		for (int j = 0; j <a[i]; j++)
		{
			printf("%d ", i + min);
		}
	}

实际上只需要修改一个地方就行了。

但是这个代码并不通用，我们一般知道数组的元素和大小，所以只用写一个排序的接口就行。下面是一个通用的代码：

void CountSort(int* a, int n)
{
	int min = a[0], max = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
	}
	int range = max - min + 1;
	//int* b = new int[range];c++语法
	int* b =(int*) malloc(sizeof(int) * range);
	memset(b, 0, sizeof(int)*range);
	for (int i = 0; i < n; i++)
	{
		b[a[i] - min]++;
	}
	int count = 0;
	for (int i = 0; i < range; i++)
	{
		for (int j = 0; j < b[i]; j++)
		{
			a[count++] = i + min;
		}
	}

}

2.冒泡排序

冒泡排序的概念

把数进行两两进行比较，遍历完一次都会把最大的元素放在了后面（或者将最小的数放在最前面），是一种非常容易理解的排序方法。

这是一趟排序的结果，将最大的数放在了最后面，那一共要进行多少趟呢？（可以先想想再往下看）

一共要进行n-1趟，所以我们用两个循环就完成了排序。
下面就是代码：

void Swap(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}
void BubbleSort(int* a, int n)
{
	for (int i = 0; i <n-1; i++)
	{
		for (int j =0;j<n-i-1;j++)
		{
			if (a[j] > a[j+1])
			{
				Swap(a[j], a[j+1]);
			}
		}
	}

}

这里要注意越界问题就是j<n-1-i这一步可以仔细思考一下
大家有没有想过这样一个问题，如果数组已经是有序的了，那么还要一个个进行比较吗（不用，是不是直接退出（break）就可以了）？
这里就提到了冒泡排序的优化，实际上就是加入一个变量检测它是否已经有序。

void BubbleSort(int* a, int n)
{
	for (int i = 0; i <n-1; i++)
	{
		int exchange = 1;
		for (int j =0;j<n-i-1;j++)
		{
			if (a[j] > a[j+1])
			{
				Swap(a[j], a[j+1]);
				exchange = 0;
			}
		}
		if (exchange == 1)
		{
			break;
		}
	}

}

3.快速排序

快速排序的概念

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

看了上面的介绍后是不是还是不了解什么是快速排序，没关系，下面用一个例子带你理解快速排序。
在这里我们先引入一个基准数的概念（不要被这个名词给吓住了，这就是一个用来参考的数）请看下面的例子：

这是一个初始无序的数组，我们就选第一个为基准数，我们的目标是把6移到中间的某个位置，并且让6左边的数都比它小，6右边的数都比它大。你有什么好办法吗？（先自己想想）
通过我们之前学的冒泡排序，我们就想到一个办法了，就是用交换的方法。
方法其实很简单：其实上就是从两端开始进行探测，先从右边找到一个比6小的数，在从左边找到一个比6大的数，之后交换它们。（这里用到了双指针的思想）。我们定义两个变量i,j一开始i从最左边也就是1的位置开始（指向1），因为基准数的位置是0，j从最右边开始，也就是9的位置开始（指向8）

这里j从右边向左边找（j–），找到5小于6，i从左向右先开始找（i++），找到7大于6，把7和5进行交换。

交换后

然后i继续往右走（i++）找到9比6大，j继续往左走（j–），找到4比6小，进行交换

交换后

这时i继续往后走（i–），j继续往左走（j–）i和j在3相遇，此时将3和6进行交换。第一轮探测就算是结束了。

这时同学门发现数组是不是变得比较有序了，如果我们用这种思维让基准数左边也变得有序，基准数右边也变得有序，那么最后整个数组是不是就都变得有序了。下面是排序的整个图。

下面是具体的代码

void QuickSort(int* a, int begin,int end)
{
	if (begin >= end) 递归一定要有结束条件，这里的就是当左右下标相等。
	{
		return;
	}
	int key = begin; 基准数
	int i = begin+1, j =end;
	while (i < j)
	{
		while (a[j] > a[key] && i < j) 从右边找比基准数小的数
		{
			j--;
		}
		while (a[i] < a[key] && i < j) 从左边找比基准数大的数
		{
			i++;
		}
		Swap(a[i], a[j]); 交换它们
	}
	Swap(a[key], a[i]); 交换基准数和i和j相遇的数
	key = i;
	QuickSort(a,begin,key-1); 对左边实现递归操作
	QuickSort(a,key+1,end);   对右边实现递归操作
}

这里有一个值得大家思考的问题：那就是为什么要先从右边开始检测而不是先从左边开始检测呢？

这是因为从右边找比基准数小的数，先从右边，最后一定是在比基准数小的数相遇，这时交换它和基准数没有问题。而从左边找比基准数大的数，先从左边，最后一定是在比基准数大的位置相遇，这是交换它和基准数，最后就不满足左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值。

铁汁们，求个关注，后面会继续更新剩下的排序算法以及其他常见的算法，排序算法的最后会说明几种算法的时间和空间复杂度以及什么场景下适合使用。希望老铁们来个三连！