排序算法

作者：whj95

前言及总览

前言

排序舞：以下视频是由Sapientia University创作的，比较生动形象地表现了排序的步骤，供大家预习及理解
　　①冒泡排序视频
　　②选择排序视频
　　③插入排序视频
　　④希尔排序视频
　　⑤归并排序视频
　　⑥快速排序视频

可视化排序：
魔性的15种排序方法
　　来源于B站，可以等看完下文了解了这些排序之后看，也可以参考视频中的绿字弹幕解说看，初步对这些排序大概有个概念。
　　具体关心左上角排序名称、主图的排序速度、以及上方居中的数据量

数据可视化
　　强无敌的可视化过程

总览

　　
　　基本排序方法：①选择排序；②冒泡排序；③插入排序
　　进阶排序方法：希尔排序；
　　高级排序方法：①归并排序；②堆排序；③快速排序
　　线性排序方法：①计数排序；②基数排序；③桶排序

交换排序

选择排序

定义
找到当前元素中最小的那个放在前面

可视化过程

代码实现
一层增初值，最小值与下标默认当前，末尾交换当前与最小；二层移光标比大小，记下标

void select_sort(int a[],int n)
{
    for(int i = 0; i < n; i++)
    {
        int min = a[i]; 
        int index = i;
        for(int j = i + 1; j < n; j++)
        {
            if(a[j] < min)
            { 
                 min = a[j]; 
                 index = j;
            }       
        }      
    if (index != i)  
            swap(a[i], a[index]);
    }
}

优点：
没有优点让你考虑用它，就是它最大的优点
缺点：
①不稳定。
②平均时间为O（n$^2$）。因此为了改进寻找最小元引出了用最小堆的堆排序。

冒泡排序 (Bubble sort)

定义
顾名思义，相邻两者两两PK，将下方的数不断“上浮”。

可视化过程

代码实现

void bubble_sort(int a[],int n)
{
    for(int i = n - 1; i >= 0; j--)//每次循环最下面的一定已经排好
    {
        bool flag = 0;//优化冒泡排序，若从头到尾没有进行过交换则已经排好，所以退出循环
        for(int j = 0; j < i; i++)
            if(a[j] > a[j+1])
            {
                swap(a[j],a[j+1])
                flag = 1;
            }
        if(flag == 0)
            break;
    }
}

优点：
稳定。一次确定位置。可实现部分排序
缺点：
交换相邻元素的算法不高效，会与逆序对有关，复杂度为O（n + i），其中i为逆序对个数，而i的平均个数为n（n-1）/4，所以平均时间为O（n$^2$）

插入排序

定义
类似玩扑克牌，把最后一张牌往大小合适的位置插入

可视化过程

代码实现
一层增初值；二层找到比当前元素小的，腾地插空

void insert_sort(int a[],int n)
{
    for(int i = 1; i < n; i++)//默认已有一个数
    {
        tmp = a[i];
        for(int j = i; j > 0 && a[j] > tmp; j--)
            a[i] = a[i-1];
        a[i] = tmp;
    }
}

优点：
① 稳定；
②比较次数和移动次数与初始排列有关；最好情况下只需O（n）时间
缺点：
不够快，不过算是基本排序中最好的算法了

希尔排序

定义
步长不断变化的直接插入排序

可视化过程

代码实现
一层定步长，二层增初值，三层腾地插

void hill_sort(int a[],int n)
{
    for(int step = n/2; step > 0; step/=2)
        for(int i = step; i < n; i++)//下面都是插入排序
        {
            int tmp = a[i];
            for(int j = i; j >= step && a[j-step] > tmp; j-=step)
                a[i] = a[i-step];
            a[i] = tmp;
        }
}

优点：克服了相邻元素比较的拘束，打破了排序必O（n$^2$）的断言
缺点：
不稳定。由于二分不互质，会导致有几种步长比较没用。以此改进的有奇数增量序列，Hibbard增量序列，Sedgewick增量序列等希尔排序。

归并排序 (Merge sort)

定义
分治经典例子。可以理解为国家队想挑选队员出征国际赛场，首先会从各省队中挑选，省队又从各市队挑选

可视化过程
如何对38,27,43,3,9,82,10进行归并排序

代码实现

void Merge_sort(int low, int high)
{
    int mid = (low + high) / 2;
    if (low == high)
        return;
    Merge_sort(low, mid);//前半部分
    Merge_sort(mid + 1, high);//后半部分
    int tal1 = low, tal2 = mid + 1, tal = low;
    while ((tal1 <= mid) && (tal2 <= high))//前半部分和后半部分都未遍历完
    {
        if (a[tal1] < a[tal2])
            b[tal++] = a[tal1++];
        else
            b[tal++] = a[tal2++];
    }
    while (tal1 <= mid)//只剩前半部分，直接放入目标数组
        b[tal++] = a[tal1++];
    while (tal2 <= high)//只剩后半部分，直接放入目标数组
        b[tal++] = a[tal2++];
}

复杂度分析：

T(N) = 2T(N/2)+cN = 2[2T(N/2^2) + cN/2] + cN = … = 2^kO(1) + ckN 　　
∵N/2^k = 1 　　
∴k = logN 　　
即T(N) = O(NlogN)

堆排序 (Heap sort)

定义
利用二叉树结构，结合了插入排序（原地排序）和归并排序（O（nlgn））各自的优点

可视化过程
我是图

流程
①维护堆maxheapify
②建堆bulid_maxheap
③堆排序heap_sort

代码实现

                                        /*维护堆maxheapify*/
/*从上往下追溯是否满足堆结构，不满足进行交换，对交换过的子树重复递归过程。递归在无交换节点时终止*/
void maxheapify(int a[], int parent, int n)
{
    int l,r,largest;//l,r分别表示左右子节点下标，largest存储最大值下标
    l = parent * 2,r = parent * 2 + 1;
    if(l <= n && a[l] > a[parent])//有左孩子&&大于根节点
        largest = l;
    else
        largest = parent;
    if (r <= n && a[r] > a[parent])
        largest = r;
    if(largest != parent)//如果发生了交换，需递归调整交换后的子树
    {
        swap(a[largest],a[parent]);
        maxheapify(a,largest);
    }
}

void swap(int a,int b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

                                        /*建堆bulid_maxheap*/
/*自底向上，循环调用maxheapify调整数组为堆*/
void bulid_maxheap(int a[])
{
    for(int i = floor(n/2); i >= 1; --i)
        maxheapify(a, i, sizeof(a)/sizeof(int));
}
                                        /*堆排序heap_sort*/
/*交换最末叶节点和根节点值确定最大值，每次交换紧跟最大堆化，注意要排除已排序的最末叶节点*/                    
void heap_sort(int a[],int n)
{
    bulid_maxheap(int a[]);
    for(int i = n; i >= 2; --i)
    {
        swap(a[1],a[i]);
        maxheapify(a, 1, i - 1);
    }
}

复杂度分析：

①维护堆maxheapify
T(N) ≤ T(2N/3)+c ≤ [T(N*(2/3)^2) + c)] + c ≤ … ≤kO(1) + kc　　
∵N*(2/3)^k = 1 　　
∴k = logN 　　
→T(N) = O(logN)

②建堆bulid_maxheap
由于调用了n次维护过程，所以时间复杂度为O（N*logN），其实更为精确的解为O（N）

③堆排序heap_sort
建堆+n次维护，所以时间复杂度为O（N）+ O（N*logN）=O(NlogN)

快速排序 (Quicksort)

定义
①取序列中的元素作为枢轴(pivot)，将整个对象序列划分为左右两个子序列。然后递归执行。
②左侧子序列中所有对象小于或等于枢轴，右侧子序列中所有对象大于枢轴
③每一趟枢轴位置即为最终位置

可视化过程

代码实现

/*下面代码是以第一个元素为枢轴。*/
/*而实际“三者取中”比较好，不容易退化*/
void qsort(int a[],int left,int right)
{
    int last;
    if(left >= right)
        return;
    swap(left,(left + right) / 2);
    last = left;
    for(int i = left + 1; i <= right; ++i)
        if(a[i] < a[left])
            swap(++last,i);
    swap(left,last);
    qsort(a,left,last - 1);
    qsort(a,last + 1,right);
}

void swap(int i,int j)
{
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

优点：
①快。对于无序且数量大的序列非常快，O（nlogn）的速度无愧于“快速”二字。当枢轴选得好，其划分均匀，递归树的高度平衡
②每一趟总能至少确定一个元素的最终位置。
缺点：
①不稳定。
②需要额外空间S（log$_2$n），最坏时需要O（n）
③序列为正序或逆序时其退化为斜树，时间复杂度变O（n$^2$），因此当比较数量小时改用直接插入排序，或是堆排序。而使用堆排序改进的方法称为内省排序。

　　

线性时间排序

计数排序 (Counting sort)

定义
空间代时间，把乱序的离散数字映射到一张有序的连续表上

代码实现

void counting_sort(int a[], int b[], int n)  //所需空间为 2*n+k
{  
       int c[n];
       memset(c,0,sizeof(c)/sizeof(int)); 

       //统计数组中，每个元素出现的次数    
       for(int i = 0; i < n; ++i)
               c[a[i]] = ++c[a[i]];  

       //统计数组计数，每项存前N项和
       for(int i = 1; i <= n; ++i)
               c[i] += c[i-1];  

       //将计数排序结果转化为数组元素的真实排序结果
       for(int i = n - 1 ; i >= 0; --i)
       {  
           b[c[a[i]]] = a[i];
           --c[a[i]];
       }  
}  

优点：
当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。
缺点：
①由于计数数组的长度取决于待排序数组中数据的范围，这意味着计数排序需要大量内存。
②无法排序人名

上述两个缺点，引出了基数排序的方法。

基数排序(radix sort)

定义
简单来讲就是将数字拆分为个位十位百位，每个位依次排序。

可视化过程
千言万语不如一张图

基数排序分为MSD(Most Significant Dight)和LSD(Least Significant Dight)，上述的方法即为LSD。不同于正常的比较思维，通常LSD排序更为常用，因为LSD不需要分堆对每堆单独排序，所以往往比MSD简单且开销小。

void radix_sort(int arr[],int begin,int end,int d)  
{    
    const int radix = 10;   
    int count[radix], i, j; 

    int *bucket = (int*)malloc((end-begin+1)*sizeof(int));  //所有桶的空间开辟   

    //按照分配标准依次进行排序过程
    for(int k = 1; k <= d; ++k)  
    {  
        //置空
        for(i = 0; i < radix; i++)  
            count[i] = 0;                   
        //统计各个桶中所盛数据个数
        for(i = begin; i <= end; i++) 
           count[getdigit(arr[i], k)]++;
        //count[i]表示第i个桶的右边界索引
        for(i = 1; i < radix; i++) 
            count[i] = count[i] + count[i-1];
        //把数据依次装入桶(注意装入时候的分配技巧)
        for(i = end;i >= begin; --i)        //这里要从右向左扫描，保证排序稳定性   
        {    
            j = getdigit(arr[i], k);        //求出关键码的第k位的数字， 例如：576的第3位是5   
            bucket[count[j]-1] = arr[i]; //放入对应的桶中，count[j]-1是第j个桶的右边界索引 
            --count[j];               //对应桶的装入数据索引减一  
        } 

        //注意：此时count[i]为第i个桶左边界  

        //从各个桶中收集数据
        for(i = begin,j = 0; i <= end; ++i, ++j)  
            arr[i] = bucket[j];       
    }     
}  

基数排序对每一位的排序都要使用计数排序。假设带排数字有n个，每个数字均为d位数，每一数位有k个取值，则其时间复杂度为O(d*(n+k))

桶排序 (Bucket sort)

定义
桶排序也是计数排序的变种，它将计数排序中相邻的m个”小桶”整合到一个”大桶”中，对每个大桶内部进行排序，最后合并大桶（一般用链表实现）。

伪代码
void bucket_sort(int a[], int n)
{
    int b[n];
    memset(b,0,sizeof(b)/sizeof(int));
    for(int i = 0; i < n; ++i)
        insert a[i] into b[floor(na[i])];
    for(int i = 0; i < n; ++i)
        sort b[i];
    concatenate b[0],b[1],...,b[n-1] together
}

优点：
①桶排序的平均时间复杂度为O(N+C)，其中C为桶内快排的时间复杂度。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。
②桶排序是稳定的
缺点：
桶排序的空间复杂度为S(N+M)，当输入数据非常庞大而桶的数量也非常多时，空间代价相当之高。

C++中的sort

#include<algorithm>

/*第一个参数是首地址，第二个是末尾地址，第三个是比较函数*/
std::sort(a, a+n, compare_function);

/*compare_function1自定义按平方从小到大返回*/
bool compare_function1(int i, int j) 
{ 
    return (i*i<j*j); 
} 

/*compare_function2自定义按类的关键字i从小到大排序*/
class obj
{
public: 
    int i;
    char ch
}; 
bool compare_function2(obj a, obj b) 
{ 
    return a.i < b.i; 
}