常用十大排序算法

概述

一、Sorting Algorithms Animations

排序算法动画： https://www.toptal.com/developers/sorting-algorithms

二、算法的分类

    十种常见排序算法可以分为两大类：

1. 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
2. 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。
   

三、时间复杂度

1.相关概念

3. 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
4. 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
5. 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
6. 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

算法

一、冒泡排序

    冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1. 算法描述

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成。

2. 动画演示

3. 代码实现

// 冒泡排序
void BubbleSort(vector<int> &vecData)
{
	size_t nLen = vecData.size();
	if (nLen <= 1)
	{
		return;
	}

	for (size_t i = 0; i < nLen - 1; i++)
	{
		bool bSweep = false;

		for (size_t j = 0; j < nLen - 1 - i; j++)
		{
			if (vecData.at(j) > vecData.at(j + 1))
			{
				bSweep = true;
				swap(vecData.at(j), vecData.at(j + 1));
			}
		}

		if (!bSweep)
		{
			return;
		}
				
	}
}

二、快速排序

    快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

1. 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

2. 动画演示

详细图解：https://blog.csdn.net/weixin_42437295/article/details/90771962

3. 代码实现

void QuickSort(vector<int>& vecData, int nLow, int nHight)
{
	if (nLow >= nHight)
	{
		return;
	}

	// 1. 设置两个探测针
	int nLpos = nLow;
	int nRpos = nHight;

	int nProvit = vecData.at(nLow);		// 2. 将首选元素设为基准值

	// 移动两侧探测针，直到它们相遇
	while ( nLpos < nRpos )
	{
		// 设定的是左边的基准值，所以先从右边开始
		// 3. 移动右侧探针，直到遇到第一个比基准值小的数停止
		while (nLpos < nRpos && vecData.at(nRpos) >= nProvit)
		{
			nRpos--;
		}

		// 4. 移动左侧探针，直到遇到第一个比基准值大的数停止
		while (nLpos < nRpos && vecData.at(nLpos) <= nProvit)
		{
			nLpos++;
		}

		// 5. 如果两探针没有相遇，交换两探针的值
		if (nLpos < nRpos)
		{
			swap(vecData.at(nLpos), vecData.at(nRpos));
		}
		
	}

	// 6. 两探测相遇，将基准值与相遇点的值交换
	swap(vecData.at(nLow), vecData.at(nRpos));

	// 此时基准值在中间，根据这个基准值将原来的数据分为了两半，左边比基准值小，右边比基准值大
	// 7. 将左右两组数据递归
	QuickSort(vecData, nLow, nLpos - 1);
	QuickSort(vecData, nLpos + 1, nHight);
}

三、简单插入排序

    插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

1. 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

2. 动画演示

3. 代码实现

void InsertSort(vector<int>& vecData)
{
	if (vecData.size() <= 1)
	{
		return;
	}

	// 1. 从首元素之后迭代容器
	for (int i = 1; i < vecData.size(); i++)
	{
		// 记录下已排序好的数据的最后一个数据的下标
		int nPreView = i - 1;
		int nCurrentTemp = vecData.at(i);

		// 2. 从已排序好的数据，从后往前和要插入的数据比较
		while ( nPreView >= 0 && vecData.at(nPreView) > nCurrentTemp )
		{
			// 3. 元素往后移，为插入腾出空间
			vecData.at(nPreView + 1) = vecData.at(nPreView);
			nPreView--;
		}

		vecData.at(nPreView + 1) = nCurrentTemp;
	}
}

四、希尔排序

    1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

1. 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

2. 动画演示

3. 代码实现

void ShellSort(vector<int>& vecData)
{
	int nLen = vecData.size();

	// 设置增量。之后通过增量来划分原始数据，将划分出来的数据用简单插入排序
	for ( int nGap = nLen / 2; nGap > 0; nGap /= 2)
	{
		// 插入排序
		// 1. 从第二个元素开始
		for (int i = nGap; i < nLen; i++)
		{
			int nPreView = i - nGap;
			int nCurrentTemp = vecData.at(i);

			// 2. 从已排序好的数据，从后往前和要插入的数据比较
			while ( nPreView >= 0 && vecData.at(nPreView) > nCurrentTemp)
			{
				// 3. 元素往后移，为插入腾出空间
				vecData.at(nPreView + nGap) = vecData.at(nPreView);
				nPreView -= nGap;
			}

			//4. 插入元素
			vecData.at(nPreView + nGap) = nCurrentTemp;
			
		}
	}

}

五、简单选择排序

    选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

1. 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

1. 初始状态：无序区为R[1…n]，有序区为空；
2. 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
3. n-1趟结束，数组有序化了。

2. 动画演示

3. 代码实现

void SelectionSort(vector<int>& vecData)
{
	int nLen = vecData.size();
	int nMinIndex;

	// 1. 迭代容器
	for ( int i = 0; i < nLen - 1; i++)
	{
		nMinIndex = i;

		for (int j = i + 1; j < nLen; j++)
		{
			// 2. 选择出最小的数
			if (vecData.at(j) < vecData.at(nMinIndex))
			{
				nMinIndex = j;
			}
		}	

		// 3. 将最小的数放到前面
		swap(vecData.at(i), vecData.at(nMinIndex));
	}
}

六、堆排序

    堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

1. 算法描述

1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

2. 动画演示

3. 代码实现

七、归并排序

    归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
图解：https://www.jianshu.com/p/95c69f8e47e7

1. 算法描述

1. 把长度为n的输入序列分成两个长度为n/2的子序列；
2. 对这两个子序列分别采用归并排序；
3. 将两个排序好的子序列合并成一个最终的排序序列。

2. 动画演示

3. 代码实现

void Merge(vector<int>& vecData, int nLpos, int nMidPos, int nRpos)
{
	// 1. 记录下左、右两端的开始位置
	int nPL = nLpos, nPR = nMidPos + 1;

	// 新建一个填充数组
	int nPos = 0;
	vector<int> vecTemp(nRpos - nLpos + 1);

	// 2. 比较两端数据，填入填充数组
	while (nPL <= nMidPos && nPR <= nRpos)
	{
		// 3. 如果左端小于右端，则左端填入，左端加1
		if (vecData.at(nPL) < vecData.at(nPR))
		{
			vecTemp.at(nPos) = vecData.at(nPL);
			nPL++;
		}
		else
		{
			vecTemp.at(nPos) = vecData.at(nPR);
			nPR++;
		}

		nPos++;
	}

	// 4. 上面的循环退出后，有一端可能已经全部填入了，所以另一端就不需要比较，直接填入
	while (nPL <= nMidPos)
	{
		vecTemp.at(nPos++) = vecData.at(nPL++);
	}

	while (nPR <= nRpos)
	{
		vecTemp.at(nPos++) = vecData.at(nPR++);
	}

	// 把最终的排序的结果复制给原数组
	for (int i = 0; i < vecTemp.size(); i++)
	{
		vecData.at(nLpos + i) = vecTemp.at(i);
	}
}

void MergeSort(vector<int>& vecData, int nLpos, int nRpos)
{
	if (nLpos == nRpos)
	{
		return;
	}

	int nMidPos = nLpos + (nRpos - nLpos) / 2;
	MergeSort(vecData, nLpos, nMidPos);			// 左半部分集合进行排序
	MergeSort(vecData, nMidPos + 1, nRpos);		// 右半部分集合进行排序
	Merge(vecData, nLpos, nMidPos, nRpos);  // 将左右子集合合并，即完成整个集合的排序
}

八、计数排序

    计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
图解：https://www.itcodemonkey.com/article/11750.html

1. 算法描述

1. 找出待排序的数组中最大和最小的元素；
2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

2. 动画演示

3. 代码实现

void CountingSort(vector<int>& vecData)
{
	if (vecData.size() <= 1)
	{
		return;
	}

	int nMax, nMin;
	nMax = nMin = vecData.at(0);

	// 1. 找出最大最小值
	for (auto elem : vecData)
	{
		if (elem > nMax)
		{
			nMax = elem;
		}

		if (elem < nMin)
		{
			nMin = elem;
		}
	}

	// 2. 建立统计数组
	vector<int> vecCount(nMax - nMin + 1);

	// 3. 将数据存入统计数组
	for (auto elem : vecData)
	{
		vecCount.at(elem - nMin)++;
	}

	// 4. 归还数据
	vecData.clear();

	for (int i = 0; i < vecCount.size(); i++)
	{
		for (int j = 0; j < vecCount.at(i); j++)
		{
			vecData.push_back(i + 1);
		}
	}
}

九、桶排序

    桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

1. 算法描述

1. 设置一个定量的数组当作空桶；
2. 遍历输入数据，并且把数据一个一个放到对应的桶里去；
3. 对每个不是空的桶进行排序；
4. 从不是空的桶里把排好序的数据拼接起来。

2. 动画演示

3. 代码实现

void BucketSort(vector<int>& vecData)
{
	if (vecData.size() <= 1)
	{
		return;
	}

	// 根据0-9, 10-99, 100-999...划分桶
	// 1. 求出最大最小值
	int nMax, nMin;
	nMax = nMin = vecData.at(0);

	for (auto elem : vecData)
	{
		if (nMin > elem)
		{
			nMin = elem;
		}

		if (nMax < elem)
		{
			nMax = elem;
		}
	}

	// 2. 求出要划分出几个桶
	int nBucketNum = (nMax - nMin) / 10 + 1;

	// 3. 建立桶
	vector<list<int>> vecBuckets(nBucketNum);

	// 4. 将数据填入桶中
	for (auto elem : vecData)
	{
		vecBuckets.at( elem / 10).push_back(elem);
	}

	// 5. 对桶里元素排序
	for (auto & elem : vecBuckets)
	{
		elem.sort();
	}

	// 6. 赋值给原先容器
	vecData.clear();
	for (auto elem : vecBuckets)
	{
		for (auto data : elem)
		{
			vecData.push_back(data);
		}
	}

}

十、基数排序

    基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

1. 算法描述

1. 取得数组中的最大数，并取得位数；
2. arr为原始数组，从最低位开始取每个位组成radix数组；
3. 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

2. 动画演示

3. 代码实现

void BaseSort(vector<int>& vecData)
{
	if (vecData.size() <= 1)
	{
		return;
	}

	// 1. 求出数据中的最大一个数的位数
	int nMaxNumb = vecData.at(0);
	for (auto elem : vecData)
	{
		nMaxNumb = nMaxNumb > elem ? nMaxNumb : elem;
	}

	int nBits = 1;
	while ( nMaxNumb /= 10)
	{
		nBits++;
	}

	// 声明一个桶结构
	vector<vector<int>> vecBuckets(10);

	// 声明一个除数，用于控制数据的位
	int nRaidx = 1;

	// 位数决定排序的循环次数
	for (int i = 0; i < nBits; i++)
	{
		// 2. 清空桶
		for (int i = 0; i < vecBuckets.size(); i++)
		{
			vecBuckets.at(i).clear();
		}

		// 3. 将数据存入桶中
		for (auto elem : vecData)
		{
			vecBuckets.at((elem / nRaidx) % 10).push_back(elem);
		}

		// 4. 将桶中数据按次序填入原始容器中
		vecData.clear();
		for (auto elem : vecBuckets)
		{
			for (auto Data : elem)
			{
				vecData.push_back(Data);
			}
		}

		// 进行下一位排序
		nRaidx *= 10;
	}
}