2020-11-24 八大排序的原理和实现（C++）

八大排序算法

直接插入排序：【插入有序表】将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。

希尔排序：       【分组+插入】将待排序数组按照步长gap进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次将gap折半减小，循环上述操作；当gap=1时，利用直接插入，完成排序。

直接选择排序：【比较+交换】从待排序序列中，找到关键字最小的元素；如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；从余下的 N - 1 个元素中，找出关键字最小的元素，重复前面两步，直到排序结束。

堆排序：           【大顶堆】根据大顶堆的性质（a[i]>=a[2i+1] && a[i]>=a[2i+2] 所有结点都比其子结点大)进行排序，先把序列构造成大顶堆，把堆顶数据和序列末尾元素进行交换；然后对剩下N - 1个元素重新构造大顶堆，直到排序结束。

冒泡排序：       【多次比较】将序列的左右元素依次比较，保证右边的元素始终大于左边的元素； 第一轮结束后，序列最后一个元素一定是当前序列的最大值；对序列当中剩下的n-1个元素再次执行上述步骤。（对于长度为n的序列，一共需要执行n-1轮比较）

快速排序：       【挖坑填数+分治】从序列当中选择一个基准数(pivot)，这里选择序列第一个数作为基准数；将序列当中的所有数依次遍历，比基准数大的位于其右侧，比基准数小的位于其左侧；重复前面两步，直到所有子集当中只有一个元素为止。

归并排序：       【分解+合并】先使每个子序列有序，再使子序列段间有序。利用递归将序列对半拆分成两组，再继续拆分直到每组只有一个元素，认为其有序；将分组两两排序合并，L[first...mid]和L[mid+1...last]合并为有序的L[first...last]。

基数排序：       【分配+收集】通过序列中各个元素的值，对干趟的排序的N个元素进行若“分配”与“收集”来实现排序。分配：按元素的个位数字，把元素分配到序号相同的桶中；收集：当序列中所有的元素都分配到对应的桶中，再按照顺序依次将桶中的元素收集形成新的一个待排序列L；对新形成的序列L重复执行分配和收集元素中的十位、百位...直到分配完该序列中的最高位，则排序结束。

---

性能分析 

 

稳定性：假设待排序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。  

插入、冒泡、归并、基数是稳定的；希尔、选择、堆排、快排不稳定。

时间复杂度：插入、选择、冒泡、快排四个基础排序中，只有快排时间复杂度为O(nlog2n)，其他三个用到两重循环，所以都是O(n2)；希尔、堆排、归并、基数排序做了一些优化，时间复杂度要小于O(n2)。

空间复杂度：空间复杂度为O(1)的排序是插入、希尔、选择、堆、冒泡，因为他们均需要额外空间存储一个数据用于交换。归并排序的空间复杂度是O(n)，临时数组+递归占用了n+logn，以上表格有误。快排的空间复杂度在递归过程中消耗，如果每次平分数组，递归过程消耗logn，最差情况消耗n，故复杂度为O(nlogn)。

---

应用场景

• 冒泡排序：数据基本有序，且数据规模较小
• 插入排序：数组基本有序，且数据规模较小
• 希尔排序：数组基本有序，且数据规模较小
• 选择排序：数据规模较小
• 堆排序：   数据规模大，或数据呈流式输入
• 归并排序：数据基本有序，且要求排序稳定时；
• 快速排序：数据乱序严重，数据规模大
• 基数排序：基数排序虽然时间复杂度较低，但需要满足的条件较多，如果能满足限制条件与空间需求，基数排序很快

---

排序算法的实现 （C++）

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <malloc.h>

using namespace std;
// sudo g++ -o sort_algorithm sort_algorithm.cpp -std=c++11

void insert_sort(int *a, int size);              // 直接插入：将元素i插入前[0,i-1]的有序表中

void shell_sort(int *a, int size);               // 希尔排序；又叫缩小增量排序，如果序列基本有序，插入排序的效率就很高，希尔排序利用了这点，是升级版的插入排序.先分组有序，再全部有序
void shell_insert(int *a, int size, int d);      // 希尔插入
    
void select_sort(int *a, int size);              // 直接选择：类似冒泡，但先确定了最小数的下标，再进行交换，减少了交换次数

void heap_sort(int *a, int size);                //堆排序：将待排序序列构造成一个大顶堆，堆顶根节点就是序列最大值，将其与末尾元素进行交换。然后将剩余n-1个元素重新构造堆，反复执行得到有序序列。
void heapAdjust(int *a, int s, int m);           // 堆调整

void bubble_sort(int *a, int size);              // 冒泡排序: 比较相邻元素，把最大的数移到最后一位，固定下来

void quick_sort(int *a, int low, int high);      // 快速排序：先把序列根据key分成左右两部分，左边比右边小，把key固定在中间位置，然后对其左右两部分调用快排函数递归
int partition(int *a, int low, int high);        // 快排分块

void merge_sort(int *a, int first, int last);    // 归并排序：把有序表划成元素个数尽量相等的两半，分别排序，然后再合并
void merge(int *a, int first, int mid, int last);

int getdigit(int x, int d);
void count_sort(int *a, int begin, int end, int d);// 基数排序：通过序列中各个元素的值进行若干次分配和收集，【分配】首先确定个位上的数字，放入对应的桶中，【收集】按顺序从桶中取数据形成新的待排序列，分别从个位排到最高位排序结束

int main(){
    int a[10] = {5, 6, 1, 2, 4, 3, 9, 3, 8, 11};
    int size = 10;
    //insert_sort(a, size);
    //select_sort(a, size);
    //bubble_sort(a, size);
    //quick_sort(a, 0, size-1);
    //heap_sort(a, size);
    //shell_sort(a, size);
    //merge_sort(a, 0, size-1);
    count_sort(a, 0, size-1, 2);
    for(auto & i : a)
        cout << i << ' ';
    cout << endl;
    return 0;
}

//直接插入排序
void insert_sort(int *a, int size){
    for(int i = 1; i < size-1; ++i){
        int key = a[i];
        int j = i-1;
        while(j>=0 && a[j]>key){
            a[j+1] = a[j];
            j--;
        } 
        a[j+1] = key;
    }
}

//希尔排序
void shell_insert(int *a, int size, int d){
    for(int i = d; i < size; i++){
        int key = a[i];
        int j;
        for(j = i; j>0 && a[j-d]>key; j = j-d){
            a[j] = a[j-d];
        }
        a[j] = key;
   }
}
void shell_sort(int *a, int size){
    int d = size/2;
    while(d >= 1){
        shell_insert(a, size, d);
        d /= 2;
    }
}

//选择排序
void select_sort(int *a, int size){
    for(int i = 0; i < size-1; ++i){
        int minIndex = i;
        for(int j = i; j < size; ++j){//找出[i,size-1]中最小数下标
            if(a[j] < a[minIndex])
                minIndex = j;
        }
        if(minIndex != i)
            swap(a[i], a[minIndex]);
    }
}

//堆排序
//(大顶堆,最大值在堆顶a[i]>=a[2i+1] && a[i]>=a[2i+2])
void heapAdjust(int *a, int s, int m){
    int key = a[s];   //先取出当前元素
    for(int j = 2*s+1; j <= m; j = 2*j+1){ // 从当前元素的左子结点开始
        if(j < m && a[j] <= a[j+1]) ++j;  // 如果左子结点<右子结点，j指向右子结点
        if(a[j] <= key) break;            // 如果结点比key小，说明key是最大的，就跳出循环
        a[s] = a[j];
        s = j;
    }
    a[s] = key;
}
void heap_sort(int *a, int size){ // 左结点：2n+1 右节点：2n+2
    for(int i = size/2-1; i>=0; --i){ // 初始建堆:从最后一个非叶子结点开始.比较它和自己的叶结点哪个大,把大的移到根节点
        heapAdjust(a, i, size-1);
    }
    for(int i = size-1; i > 0; --i){  // 取顶堆，并调整
        swap(a[0], a[i]);
        heapAdjust(a, 0, i-1);
    }
}         

//冒泡排序
void bubble_sort(int *a, int size){
    for(int i = 0; i < size-1; ++i){
        for(int j = 0; j < size-i-1; ++j){
            if(a[j] > a[j+1])
                swap(a[j], a[j+1]);
        }
    }
}

//快速排序
int partition(int *a, int low, int high){
    int key = a[low];
    while(low < high){
        while(low<high && a[high]>key) high--; // 从后往前找第一个比key小的数，挖出来往前扔
        a[low] = a[high];
        while(low<high && a[low]<=key) low++;  // 从前往后找第一个比key大的数，如果有，挖出来往后扔
        a[high] = a[low];  
    }
    a[low] = key;  // 经过以上交换，会有一个坑，用key填上，该位置就是key的正确位置
    return low;
}
void quick_sort(int *a, int low, int high){
    if(low >= high) return;
    int keypos = partition(a, low, high);
    quick_sort(a, low, keypos-1);
    quick_sort(a, keypos+1, high);
}

//归并排序
void merge(int *a, int first, int mid, int last){
    int temp[last-first+1];
    int copyIndex = last - first;
    int i = mid, j = last;
    while(i>=first && j>=mid+1){
        if(a[i]>a[j]) temp[copyIndex--] = a[i--];
        else temp[copyIndex--] = a[j--];
    }
    while(i >= first) temp[copyIndex--] = a[i--];
    while(j >= mid+1) temp[copyIndex--] = a[j--];
    for(int k = first; k <= last; ++k){
        a[k] = temp[k-first];
    }
}
void merge_sort(int *a, int first, int last){
    if(first >= last) return;
    int mid = (first + last)/2;
    merge_sort(a, first, mid);
    merge_sort(a, mid+1, last);
    merge(a, first, mid, last);
}

//基数排序
int getdigit(int x, int d){//获取d位数
    int a[] = {1, 10, 100};
    return (x/a[d])%10;
}
void count_sort(int *a, int begin, int end, int d){
    const int radix = 10; // 桶的个数 0~9
    int count[radix], i, j;
    int *bucket = (int*)malloc((end-begin+1)*sizeof(int));
    for(int k = 0; k <= d; k++){     // 如果数字最大是三位数 d = 3
        for(i = 0; i < radix; i++){  // 置零
            count[i] = 0;  
        }
        for(i = begin; i <= end; i++){ // 统计每个桶要放多少数据，count[i]记录的是第i个桶的有边界
            count[getdigit(a[i], k)]++;
        }
        for(i = 1; i < radix; i++){    // 分别建立0~9的右边界
            count[i] = count[i] + count[i-1];
        }
        for(i = end; i >= begin; i--){ // 把数据装入桶中:从右往左扫描，保证排序稳定性
            j = getdigit(a[i], k);
            bucket[count[j]-1] = a[i];
            count[j]--;
        }
        //此时count[i]记录了第i个桶的左边界
        //从桶中收集数据
        for(i = begin, j = 0; i <= end; i++,j++){
            a[i] = bucket[j];
        }
        
    }
    free(bucket);
      
}

参考链接

https://blog.csdn.net/lumaomao_/article/details/100762415

https://www.jianshu.com/p/7d037c332a9d