目录
排序
排序就是将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程。
排序的方法很多，下面介绍一些常见的排序方法，要求了解其原理，会编写代码，并会分析不同算法的时间复杂度，了解各个算法的稳定性。
稳定性指在原序列中相同元素的相对位置与排好序的新序列中相同元素的相对位置是否相同。若相同，则该算法是稳定的，否则不稳定。
1 简单排序
1．选择排序
选择排序的基本思想是：对待排序的记录序列进行n－1遍的处理，第1遍处理是将L［1..n］中最小者与L［1］交换位置，第2遍处理是将L［2..n］中最小者与L［2］交换位置……第i遍处理是将L［i..n］中最小者与L［i］交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。时间复杂度：O（n2）。选择排序是稳定排序。
void select_sort(int a[], int n)
{
int i = 0, j = 0, k = 0;
for (i=0; i < n-1; i++)
{
k = i;
for (j=i+1; j < n; j++)
{
if (a[k] > a[j])
{
k = j;
}
}
if (k != i)
{
tmp=a[k];
a[k]=a[i];
a[i]=tmp;
}
}
}
2．插入排序
插入排序的基本思想：经过i－1遍处理后，L［1..i－1］己排好序。第i遍处理仅将L［i］插入L［1..i－1］的适当位置p，原来p后的元素一一向右移动一个位置，使得L［1..i］又是排好序的序列。时间复杂度为O（n2），插入排序是稳定排序。
void InsertSort(int arr[],int n)
{
for (int i =1;i <= n;++i)
{
for(int j = i;j > 0;--j)
{
if(arr[j] < arr[j -1])
{
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}
如果使用vector的话会方便一点，因为vector可以使用size()直接获得容器内的元素个数。
void InsertSort2(vector<int> &num)
{
for(int i = 1;i < num.size();++i)
{
for(int j = i;j > 0;--j)
{
if(num[j] < num[j - 1])
{
int temp = num[j];
num[j] = num[j-1];
num[j-1] = temp;
}
}
}
}
插入排序是一种稳定的排序方法，排序元素比较少的时候很好，大量元素便会效率低下
这个图很形象，取自维基百科
3．冒泡排序
冒泡排序又称交换排序，其基本思想是：对待排序的记录的关键字进行两两比较，如发现两个记录是反序的，则进行交换，直到无反序的记录为止。时间复杂度为O（n2），冒泡排序是一个稳定的排序。
void BubbleSort(int arr[], int n)
{
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
冒泡排序感觉非常好理解，第一个for循环是遍历所有元素，第二个for循环是每次遍历元素时都对无序区的相邻两个元素进行一次比较，若反序则交换
冒泡排序感觉非常好理解，第一个for循环是遍历所有元素，第二个for循环是每次遍历元素时都对无序区的相邻两个元素进行一次比较，若反序则交换
时间复杂度最坏的情况是反序序列，要比较n(n-1)/2次，时间复杂度为O(n^2 )，最好的情况是正序，只进行(n-1)次比较，不需要移动，时间复杂度为O(n)，而平均的时间复杂度为O(n^2 )
但是还有更好的方法，如果第一次比较完没有交换即说明已经有序，不应该进行下一次遍历
还有已经遍历出部分有序的序列后，那部分也不用进行遍历，即发生交换的地方之后的地方不用遍历
void BubbleSort(int arr[], int len)
{
int i,temp;
//记录位置，当前所在位置和最后发生交换的地方
int current,last = len - 1;
while(last > 0)
{
for(i = current = 0;i < last;++i)
{
if(arr[i] > arr[i+1])
{
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
//记录当前的位置，如果没有发生交换current值即for循环初始化的0
current = i;
}
}
//若current = 0即已经没有可以交换的元素了，即已经有序了
last = current;
}
}
图取自维基
冒泡排序也是一种稳定的排序算法，也是元素较少时效率比较高
2 快速排序
快速排序的思想是：先从数据序列中选一个元素，并将序列中所有比该元素小的元素都放到它的右边或左边，再对左右两边分别用同样的方法处理直到每一个待处理的序列的长度为1，处理结束。时间复杂度下限O（nlogn），上限O（n2）。快速排序不稳定。
过程是和二叉搜索树相似，就是一个递归的过程
排序函数
QuickSort(int arr[], int first, int end)
{
int pivot = OnceSort(arr,first,end);
//已经有轴值了，再对轴值左右进行递归
QuickSort(arr,first,pivot-1);
QuickSort(arr,pivot+1,end);
}
接下来就是一次排序的函数
void OnceSort(int arr[], int first, int end)
{
int i = first,j = end;
//当i<j即移动的点还没到中间时循环
while(i < j)
{
//右边区开始，保证i<j并且arr[i]小于或者等于arr[j]的时候就向左遍历
while(i < j && arr[i] <= arr[j]) --j;
//这时候已经跳出循环，说明j>i 或者 arr[i]大于arr[j]了，如果i<j那就是arr[i]大于arr[j]，那就交换
if(i < j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//对另一边执行同样的操作
while(i < j && arr[i] <= arr[j]) ++i;
if(i < j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//返回已经移动的一边当做下次排序的轴值
return i;
}
过程解释都写在注释里面了，挺好理解的
这是我在书上看到的实现，用的是递归的方法
这个图不是一般的棒！！来自维基
快速排序时间复杂度的最好情况和平均情况一样为O(nlog2 n)，最坏情况下为O(n^2 )，这个看起来比前面两种排序都要好，但是这是不稳定的算法，并且空间复杂度高一点（ O(nlog2 n)
而且快速排序适用于元素多的情况
3 希尔排序
基本思想：将整个无序序列分割成若干小的子序列分别进行插入排序或冒泡排序。
序列分割方法：将相隔某个增量h的元素构成一个子序列。在排序过程中，逐次减小这个增量，最后当h减到1时，进行一次插入排序或冒泡排序，排序就完成。增量序列一般采用：d1＝n div 2，di＝di－1 div 2；i＝2，3，4，…其中n为待排序序列的长度。
希尔排序是一种按照增量排序的方法。其中增量值是小于n的正整数。
shell排序的基本思想[1]是：
先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
可以根据百度百科中提供的图来直观的看一下：
（1）初始增量为3，该数组分为三组分别进行排序。（初始增量值原则上可以任意设置（0<gap<n），没有限制）
（2）将增量改为2，该数组分为2组分别进行排序。
（3）将增量改为1，该数组整体进行排序。
下面是根据该数组实现的代码：
#include <iostream>
using namespace std;
int a[] = {70,30,40,10,80,20,90,100,75,60,45};
void shell_sort(int a[],int n);
int main()
{
cout<<"Before Sort: ";
for(int i=0; i<11; i++)
cout<<a[i]<<" ";
cout<<endl;
shell_sort(a, 11);
cout<<"After Sort: ";
for(int i=0; i<11; i++)
cout<<a[i]<<" ";
cout<<endl;
system("pause");
}
void shell_sort(int a[], int n)
{
int gap;
for(gap = 3; gap >0; gap--)
{
for(int i=0; i<gap; i++)
{
for(int j = i+gap; j<n; j=j+gap)
{
if(a[j]<a[j-gap])
{
int temp = a[j];
int k = j-gap;
while(k>=0&&a[k]>temp)
{
a[k+gap] = a[k];
k = k-gap;
}
a[k+gap] = temp;
}
}
}
}
}
4 堆排序
堆的结构类似于完全二叉树，每个结点的值都小于或者等于其左右孩子结点的值，或者每个节点的值都大于或等于其左右孩子的值
堆排序过程将待排序的序列构造成一个堆，选出堆中最大的移走，再把剩余的元素调整成堆，找出最大的再移走，重复直至有序
来看一下实现
//堆排序
void HeapSort(int arr[],int len)
{
int i;
//初始化堆，从最后一个父节点开始
for(i = len/2 - 1; i >= 0; --i)
{
Heapify(arr,i,len);
}
//从堆中的取出最大的元素再调整堆
for(i = len - 1;i > 0;--i)
{
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
//调整成堆
Heapify(arr,0,i);
}
}
再看 调整成堆的函数
void Heapify(int arr[], int first, int end)
{
int father = first;
int son = father * 2 + 1;
while(son < end){
if(son + 1 < end && arr[son] < arr[son+1]) ++son;
//如果父节点大于子节点则表示调整完毕
if(arr[father] > arr[son]) break;
else {
//不然就交换父节点和子节点的元素
int temp = arr[father];
arr[father] = arr[son];
arr[son] = temp;
//父和子节点变成下一个要比较的位置
father = son;
son = 2 * father + 1;
}
}
}
堆排序的时间复杂度最好到最坏都是O(nlogn)，较多元素的时候效率比较高
图来自维基
5 归并排序
归并排序的基本思想是将若干个序列进行两两归并，直至所有待排序记录都在一个有序序列为止
这个图很有概括性，来自维基
我们也可以用递归的思想，每次合并就是一次递归
首先，将一整个序列分成两个序列，两个会分成4个，这样分下去分到最小单位，然后开始合并
void Merge(int arr[], int reg[], int start, int end)
{
if (start >= end)return;
int len = end - start, mid = (len >> 1) + start;
//分成两部分
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
//然后合并
Merge(arr, reg, start1, end1);
Merge(arr, reg, start2, end2);
int k = start;
//两个序列一一比较,哪的序列的元素小就放进reg序列里面,然后位置+1再与另一个序列原来位置的元素比较
//如此反复,可以把两个有序的序列合并成一个有序的序列
while (start1 <= end1 && start2 <= end2)
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
//然后这里是分情况,如果arr2序列的已经全部都放进reg序列了然后跳出了循环
//那就表示arr序列还有更大的元素(一个或多个)没有放进reg序列,所以这一步就是接着放
while (start1 <= end1)
reg[k++] = arr[start1++];
//这一步和上面一样
while (start2 <= end2)
reg[k++] = arr[start2++];
//把已经有序的reg序列放回arr序列中
for (k = start; k <= end; k++)
arr[k] = reg[k];
}
void MergeSort(int arr[], const int len)
{
//创建一个同样长度的序列,用于临时存放
int reg[len];
Merge(arr, reg, 0, len - 1);
}
归并排序的时间复杂度都是O(nlogn)，并且适用于元素较多的时候排序
6 线性排序
前言：
比较排序的下界为o（nlogn）。那么有没有时间复杂度为o（n）的线性时间排序算法呢？在一定的假设条件下，是有更快的排序算法的，下面介绍的计数排序和桶排序等都是线性时间排序算法。
1、计数排序
计数排序便是很基础的一种线性时间排序，它是基数排序的基础。基本思想是：对每一个元素x，确定小于x的元素个数，就可以把x直接放到它在有序序列中的位置上。过程描述：假设待排序序列a中值的范围[0,k],其中k表示待排序序列中的最大值。首先用一个辅助数组count记录各个值在a中出现的次数，比如count[i]表示i在a中的个数。然后依次改变count中元素值，使count[i]表示a中不大于i的元素个数。然后从后往前扫描a数组，a中的元素根据count中的信息直接放到辅助数组b中。最后把有序序列b复制到a。
vector<int> sortCouting(const vector<int>& v, int mm) {
vector<int> coutv(mm + 1, 0),ret(v.size());
for (auto vi : v) ++coutv[vi];
for (int k1(1); k1 <= mm; ++k1) coutv[k1] += coutv[k1 - 1];
for (int k1(v.size() - 1); k1 >= 0; --k1) ret[--coutv[v[k1]]] = v[k1];
return ret;
}
2、基数排序
在计数排序中，当k很大时，时间和空间的开销都会增大（可以想一下对序列{8888,1234,9999}用计数排序，此时不但浪费很多空间，而且时间方面还不如比较排序）。于是可以把待排序记录分解成个位(第一位)、十位(第二位)....然后分别以第一位、第二位...对整个序列进行计数排序。这样的话分解出来的每一位不超过9，即用计数排序序列中最大值是9。
3、桶排序
基本原理：同计数排序一样，桶排序也对待排序序列作了假设，桶排序假设序列由一个随机过程产生，该过程将元素均匀而独立地分布在区间[0,1)上。基本思想是：把区间[0,1)划分成n个相同大小的子区间，称为桶。将n个记录分布到各个桶中去。如果有多于一个记录分到同一个桶中，需要进行桶内排序。最后依次把各个桶中的记录列出来记得到有序序列。拓展：桶排序是在已经数据的范围的条件下，创建若干个桶，根据相应的比较规则将待排数据落入各个对应的桶中，最后扫描 桶 来实现排序。如果要排序的对象不是小数型，而是整合的集合，就有下面的结论和应用。例如要对大小为[1..1000]范围内的n个整数A[1..n]排序，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储(10..20]的整数，……集合B[i]存储((i-1)*10, i*10]的整数，i = 1,2,..100。总共有100个桶。然后对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。 然后再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任何排序法都可以。最后依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这样就得到所有数字排好序的一个序列了。再例如，假设有10万个人的年龄数据，年龄范围默认是0-99，如何对这10万个数据进行排序？如果用快排啊、归并排序啊...这样的排序算法是可以。但是这样的排序问题更适合桶排序。采用桶排序的方法如下：建立100个桶，这可以用一个 一维数组来表示。a[0...99]，依次扫描10万条数据，根据每条数据的值，记录到桶中。比如，第10个人的年龄是18岁，则a[18]++ （这是将出现的频率记录在桶中，是计数，它是将待排序的元素本身进行比较，而不是将“待排序的元素的组成部分”进行比较）然后，扫描这100个桶，即可得到有序的数组。
vector<int> sortBucket(vector<int>& v, int mm) {
vector<int> bucket(mm + 1, 0);
for (auto vi : v) ++bucket[vi];
int cn(0);
for (int k1(0); k1 <= mm; ++k1) {
if (bucket[k1]) {
while(bucket[k1]--) v[cn++] = k1;
}
}
return v;
}
7 各种排序算法的比较
1．稳定性比较
插入排序、冒泡排序、二叉树排序、归并排序及其他线形排序是稳定的。
选择排序、希尔排序、快速排序、堆排序是不稳定的。
2．时间复杂性比较
插入排序、冒泡排序、选择排序的时间复杂性为O（n2）。
其他非线形排序的时间复杂性为O（nlogn）。
线形排序的时间复杂性为O（n）。
3．辅助空间的比较
线形排序、归并排序的辅助空间为O（n），其他排序的辅助空间为O（1）。
4．其他比较
（1）插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。在这种情况下，快速排序反而慢了，时间复杂度会达到其上限。当数据为随机数据时，快速排序远远快于插入、冒泡、选择排序，时间复杂度接近其下限。
（2）当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。（3）若待排序的记录的关键字在一个明显有限范围内且空间允许时，适用桶排序。
（4）当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
（5）当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求、空间允许的情况下，宜用归并排序。
（6）当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。
1401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
