十种常见排序算法的实现C++
关于常见排序算法的基本概念、思想、复杂度分析、动图等，已经有很多博客介绍，可以参考：十大经典排序算法（动图演示） 来了解基本内容。
接下来使用VS2017，在一个 .cpp 文件中，简单实现十种算法，效果图如下：
十种排序算法分别为：
- 冒泡排序
- 选择排序
- 插入排序
- 希尔排序
- 归并排序
- 快速排序
- 堆排序
- 计数排序
- 桶排序
- 基数排序
C++代码如下，VS复制可用：
#include "stdafx.h"
#include
#include "math.h"
#include
#include
#include
//排序算法说明参考链接：https://www.cnblogs.com/onepixel/articles/7674659.html
using namespace std;
void printArr(const vectorinput);//用于打印vector
/* 1、冒泡排序（Bubble Sort）
比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。*/
vector bubbleSort(vector input)
{
int lenth = input.size();
int tmp;
for (int i = 0; i < lenth - 1; i++)
{
for (int j = 0; j < lenth - i - 1; j++)
{
if (input[j] > input[j + 1])
{
int tmp = input[j];
input[j] = input[j + 1];
input[j + 1] = tmp;
}
}
}
return input;
}
/*2、选择排序（Selection Sort）
初始状态：无序区为R[1..n]，有序区为空；
第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个的新无序区；
n - 1趟结束，数组有序化了。
*/
vector selectionSort(vector input)
{
int lenth = input.size();
int min, tmp;
for (int i = 0; i < lenth - 1; i++)
{
min = i;
for (int j = i; j < lenth; j++)
{
if (input[j] < input[min])
{
min = j;
}
}
tmp = input[i];
input[i] = input[min];
input[min] = tmp;
}
return input;
}
/* 3、插入排序（Insertion Sort）
从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。*/
vector insertionSort(vector input)
{
int lenth = input.size();
int j, tmp;
for (int i = 1; i < lenth; i++)
{
j = i;
while (j)
{
if (input[j] < input[j - 1])
{
tmp = input[j];
input[j] = input[j - 1];
input[j - 1] = tmp;
}
else break;
j--;
}
}
return input;
}
/*4、希尔排序（Shell Sort）
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
选择一个增量序列t1，t2，…，tk，其中ti>tj，tk = 1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。
仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
*/
vector shellSort(vector input)
{
int lenth = input.size();
int gap = lenth;
int j, tmp;
while (gap>0)
{
gap = gap / 2;
for (int i = gap; i < lenth; i++)//for循环是插入排序，每组交替进行
{
j = i;
while (j - gap >= 0)
{
if (input[j] < input[j - gap])
{
tmp = input[j];
input[j] = input[j - gap];
input[j - gap] = tmp;
}
else break;
j = j - gap;
}
}
}
return input;
}
/*5、归并排序（Merge Sort）
把长度为n的输入序列分成两个长度为n / 2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。*/
vector mergeSort(vector input)
{
int lenth = input.size();
vectorleft, right;
//递归分为1一个个的小组
if (lenth > 1)
{
for (int i = 0; i < lenth; i++)
{
if (i < lenth / 2) left.push_back(input[i]);
else right.push_back(input[i]);
}
left = mergeSort(left);
right = mergeSort(right);
}
else {
return input;
}
//比较left和right，将其合并到一起
int left_pos = 0;
int right_pos = 0;
for (int i = 0; i < lenth; i++)
{
//左右数组的边界，到了边界就直接装另一边的
if (right_pos >= lenth - lenth / 2)
{
input[i] = left[left_pos];
left_pos++;
continue;
}
if (left_pos >= lenth / 2)
{
input[i] = right[right_pos];
right_pos++;
continue;
}
//哪个小装哪个
if (right[right_pos] >= left[left_pos])
{
input[i] = left[left_pos];
left_pos++;
continue;
}
if (right[right_pos] < left[left_pos])
{
input[i] = right[right_pos];
right_pos++;
continue;
}
}
return input;
}
/*6、快速排序（Quick Sort）
从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。*/
vector quickSort(vector input)
{
int lenth = input.size();
vectorleft, right;
int mid = 0;
int tmp;
if (lenth > 1)//以第一个作为基准,分为左小又大
{
for (int i = 1; i < lenth; i++)
{
if (input[i] < input[0])
{
left.push_back(input[i]);
mid++;
}
else {
right.push_back(input[i]);
}
}
left = quickSort(left);
right = quickSort(right);
}
else {
return input;
}
input[mid] = input[0];
//此时左右均有序，mid放中间组起来就行了
for (int i = 0; i < lenth; i++)
{
if (i < mid)
{
input[i] = left[i];
}
else if (i > mid)
{
input[i] = right[i - mid - 1];
}
}
return input;
}
/*7、堆排序（Heap Sort）
将初始待排序关键字序列(R1, R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1, R2, ……Rn - 1)和新的有序区(Rn), 且满足R[1, 2…n - 1] <= R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1, R2, ……Rn - 1)调整为新堆，
然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1, R2….Rn - 2)和新的有序区(Rn - 1, Rn)。
不断重复此过程直到有序区的元素个数为n - 1，则整个排序过程完成。*/
vector heapSort_help(vector input, int pos, int len)
{
int lenth = len;
int tmp;
int left = pos * 2 + 1;
int right = left + 1;
if (leftinput[pos])
{
tmp = input[left];
input[left] = input[pos];
input[pos] = tmp;
input = heapSort_help(input, left, len);//更新后可能子节点比子节点的子节点还小，因此需要递归将下面的排好
}
if (rightinput[pos])
{
tmp = input[right];
input[right] = input[pos];
input[pos] = tmp;
input = heapSort_help(input, right, len);//更新后可能子节点比子节点的子节点还小，因此需要递归将下面的排好
}
return input;
}
vector heapSort(vector input)
{
int lenth = input.size();
int tmp;
//当做层序遍历得到的无序序列
//从最后一个非叶子节点开始，使成为大顶堆，若每次都从头遍历，则为单纯的选择排序
if (lenth > 1)
{
for (int i = lenth / 2 - 1; i >= 0; i--)
{
input = heapSort_help(input, i, lenth);//当产生交换时，递归使子节点也为大顶堆结构，相比于不递归，则每次都要从头开始比较
}
}
else
{
return input;
}
//input已经成为大顶堆
//开始排序
for (int i = lenth - 1; i >= 0; i--)
{
//交换顶点和最后一个叶节点
tmp = input[i];
input[i] = input[0];
input[0] = tmp;
//将除了最后一个的数组继续递归
input = heapSort_help(input, 0, i);
}
return input;
}
/*8、计数排序（Counting Sort）
找出待排序的数组中最大和最小的元素；
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1*/
vector countingSort(vector input)
{
int lenth = input.size();
//数据范围为0~100，共101个数
vectortmp(101, 0);
vectoroutput;
//累计到与数据范围同长度的临时数组中
for (const auto &i : input)
{
tmp[i]++;
}
for (int i = 0; i < 101; i++)
{
for (int k = 0; k < tmp[i]; k++)
{
output.push_back(i);
}
}
return output;
}
/*9、桶排序（Bucket Sort）
设置一个定量的数组当作空桶；
遍历输入数据，并且把数据一个一个放到对应的桶里去；
对每个不是空的桶进行排序；
从不是空的桶里把排好序的数据拼接起来。 */
vector bucketSort(vector input)
{
int lenth = input.size();
int bucketNum = 5;
int max = input[0];
int min = max;
//找到最大值最小值
for (int i = 0; i < lenth; i++)
{
if (input[i] > max)
{
max = input[i];
}
if (input[i] < min)
{
min = input[i];
}
}
int bucketCount = (max - min) / bucketNum + 1;
vector>bucket(bucketCount);
//装载入各桶
for (int i = 0; i < lenth; i++)
{
bucket[(input[i] - min) / bucketNum].push_back(input[i]);
}
input.clear();
//各桶排序
for (int i = 0; i < bucketCount; i++)
{
bucket[i] = insertionSort(bucket[i]);//进行排序，这里随便用了插入排序
for (int j = 0; j < bucket[i].size(); j++)
{
input.push_back(bucket[i][j]);
}
}
return input;
}
/*10、基数排序（Radix Sort）
取得数组中的最大数，并取得位数；
arr为原始数组，从最低位开始取每个位组成radix数组；
对radix进行计数排序（利用计数排序适用于小范围数的特点）；*/
vector radixSort(vector input)
{
int lenth = input.size();
int max = input[0];
int num = 0;
int tmp;
vector>bucket(10);
//找到最大值
for (int i = 0; i < lenth; i++)
{
if (input[i] > max)
{
max = input[i];
}
}
//得到位数
while (max>0)
{
max = max / 10;
num++;
}
for (int i = 0; i < num; i++)
{
for (int k = 0; k < lenth; k++)
{
tmp = input[k] % (int)pow(10, i + 1) / (int)pow(10, i);//得到当前位上的数值
bucket[tmp].push_back(input[k]);//装入对应的桶
}
input.clear();
for (int k = 0; k < 10; k++)
{
for (int j = 0; j < bucket[k].size(); j++)
{
input.push_back(bucket[k][j]);//一个个装回去
}
bucket[k].clear();
}
}
return input;
}
/*打印vector的函数*/
void printArr(const vectorinput)
{
for (auto iterator = input.begin(); iterator < input.end(); iterator++)
{
cout << *iterator << " ";
}
cout << endl;
}
/*主函数，分别打印十种排序的处理结果，getchar()使控制台窗口停留*/
int main()
{
vector arr = { 25,3,43,12,4,100,66,8,32 };//示例//数据范围为0~100
cout << "排序结果：" << endl;
printArr(bubbleSort(arr));
printArr(selectionSort(arr));
printArr(insertionSort(arr));
printArr(shellSort(arr));
printArr(mergeSort(arr));
printArr(quickSort(arr));
printArr(heapSort(arr));
printArr(countingSort(arr));
printArr(bucketSort(arr));
printArr(radixSort(arr));
getchar();
return 0;
}