排序算法详解

最新推荐文章于 2024-10-25 13:33:57 发布

DuanHDcn

最新推荐文章于 2024-10-25 13:33:57 发布

阅读量196

点赞数

分类专栏：算法文章标签：排序算法

本文链接：https://blog.csdn.net/wucui9370/article/details/93920080

版权

算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

注：本文大部分为转载，较少部分为原创。

排序算法导图

排序算法导图，由XMind8制作。

选择排序

思想

选择排序(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趟结束，数组有序化了。

动图演示

选择排序演示

C++代码

template <typename T>
void selectionSort(vector<T> data) {
    for (int i = 0; i+1 < data.size(); ++i) {
        int min_idx = i;
        for (int j = i+1; j < data.size(); ++j) {
            if (data[min_idx] < data[j])
                min_idx = j;
        }
        swap(data[min_idx], data[i]);
    }
}

复杂度分析

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n²)的时间复杂度。不占用额外的内存空间。

冒泡排序

思想

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

具体描述

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

动图演示

冒泡排序演示

C++代码

template <typename T>
void bubbleSort(vector<T> data) {
    for (int i = 0; i+1 < data.size(); ++i) {
        for (int j = 0; j+1+i < data.size(); ++j) {
            if (data[j] > data[j+1])
                swap(data[j], data[j+1]);
        }
    }
}

复杂度分析

不管原始数组是否有序，时间复杂度都是O(n²)，因为每次扫描时每一个数都要与相邻数比较一次。不占用额外空间。

改进

可以用一个flag标识该轮扫描时是否交换过数据，如果没有可以停止扫描。

插入排序

思想

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

具体描述

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

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

动图展示

插入排序演示

C++代码

template <typename T>
void insertionSort(vector<T> data) {
    for (int i = 1; i < data.size(); ++i) {
        T val = data[i];
        int j = i-1;
        while (j >= 0 && val < data[j]) {
            data[j+1] = data[j];
            --j;
        }
        data[j+1] = val;
    }
}

复杂度分析

插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
对于有序数组，只需要n-1次键值比较；对于严格递减的数组，插入排序和选择排序的键值比较次数相同。因此，插入排序的平均复杂度优于选择比较。

改进

二分插入排序的基本思想和插入排序一致；都是将某个元素插入到已经有序的序列的正确的位置；二分插入排序，利用前k-1个元素已经是有序的特点结合二分查找，找到正确的位置，因此每轮的比较次数为log(k)。总的时间复杂度为
$O(\sum_2^{n-1}\log i) = O(\log(n!)) = O(n\log n)$

希尔排序

思想

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

具体描述

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

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

动图演示

希尔排序演示

C++代码

template <typename T>
void shellSort(vector<T> data) {
    for(int gap = data.size()/2; gap > 0; gap /= 2) {
        for (int i = gap; i < data.size(); i += gap) {
            int val = data[i];
            int j = i-gap;
            while (j >= 0 && val < data[j]) {
                data[j+gap] = data[j];
                j -= gap;
            }
            data[j+gap] = val;
        }
    }
}

复杂度分析

Shell排序的执行时间依赖于增量序列。不需要额外空间。
好的增量序列的共同特征：① 最后一个增量必须为1；② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况(前面的代码就不够好)。
Shell增量：{1, 2, 4, …, 2^k}
Hibbard增量：{1, 3, …, 2^k-1}
Sedgewick增量：{1, 5, 19, 41, 109…}
有关增量序列的知识请进一步查找参看资料。

归并排序

思想

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

具体描述

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

动图演示

归并排序演示

C++代码

template <typename T>
void mergeSort(vector<T> data, size_t left, size_t right) {
    if (left < right) {
        size_t middle = (left + right)/2;
        mergeSort(data, left, middle);
        merge_sort(data, middle+1, right);
        merge(data, left, right);
    }
}

void merge(vector<T> data, size_t l, size_t r) {
    size_t mid = (l + r) / 2;
    size_t i = l;
    size_t j = mid + 1;
    size_t count = 0;
    T temp[] = new T[r-l+1];
    while (i <= mid && j <= r) {
        if (data[i] < data[j]) 
            temp[count++] = data[i++];
        else 
            temp[count++] = data[j++];
    }
    while (i <= mid) 
        temp[count++] = data[i++];
    while (j <= r) 
        temp[count++] = data[j++];
    count = 0;
    while (l <= r) 
        data[l++] = temp[count++];
}

复杂度分析

归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。

快速排序

思想

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

具体描述

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

动图演示

快速排序演示

C++代码

template <typename T>
void quickSort(vector<T> data) {
    if(data.size() > 0)
        quickSort(data, 0, data.size()-1);
}

// 从后往前找到一个大于pivot的数，从前往后找到一个小于pivot的数，交换
void quickSort(vector<T> data, int low, int high) {
    if(low > high)
        return;  
    int i = low; 
    int j = high;
    T key = data[low];
    while(i < j) {  
        while(i < j && data[j] > key)  
            j--;    
        while(i < j && data[i] <= key) 
            i++;  
        if(i < j) {
            swap(data[i], data[j]);
    }
    swap(data[i], data[low]);
    quickSort(data, low, i-1);  
    quickSort(data, i+1, high);  
}

复杂度分析

快速排序的平均复杂度为O(nlogn)，空间复杂度为O(1)。
最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候（设输入的表有n个元素），此时复杂度为O(n²)。

堆排序

思想

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

算法描述

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

动图演示

堆排序演示

C++代码

复杂度分析

计数排序

思想

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

具体描述

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

动图演示

基数排序演示

C++代码

void countSort(vector<int> data, int max_val) {
    vector<int> count_array(range+1);
    vector<int> temp = data;
    for (int i = 0; i < data.size(); ++i)
        +count_array[data[i]];
    for (int i = 1; i < count_array.size(); ++i)
        count_array[i] += count_array[i-1];
    for (int i = (int)data.size()-1; i >= 0; --i) {
        data[count_array[data[i]] - 1] = temp[i];
        --count_array[data[i]];
    }
}

复杂度分析

计数排序是一个稳定的排序算法。当输入的元素是n个0到k之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)。其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

桶排序

思想

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

具体描述

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

动图演示

桶排序动图演示

C++代码

复杂度分析

桶排序最好情况下使用线性时间O(n),桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

基数排序

思想

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

具体描述

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

动图演示

基数排序动图演示

C++代码

//寻找数组中最大数的位数作为基数排序循环次数
int KeySize(int a[], int n){
    int key = 1;
    for(int i=0;i<n;i++){
        int temp = 1;
        int r = 10;
        while(a[i]/r>0){
            temp++;
            r*=10;
        }
        key = (temp>key)?temp:key;
    }
    return key;
}

//基数排序
void RadixSort(int a[], int n){
    int key = KeySize(a,n);
    int bucket[10][10]={0};
    int order[10]={0};
    for(int r = 1;key>0;key--,r*=10){
        for(int i=0;i<n;i++){
             int lsd = (a[i]/r)%10;
             bucket[lsd][order[lsd]++]=a[i];
        }

        int k = 0;
        for(int i = 0;i<10;i++){
            if(order[i]!=0){
                for(int j = 0;j<order[i];j++)
                    a[k++]=bucket[i][j];
            }
            order[i]=0;
        }
    }
}

复杂度分析

基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。

稳定性

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面。

杂谈

如果把数组改成链表，会影响哪些排序方法的复杂度？
答：

总结

排序方法	时间复杂度（最好）	时间复杂度（最坏）	时间复杂度（平均）	空间复杂度	稳定性
选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
冒泡排序	O(n)	O(n²)	O(n²)	O(1)	稳定
插入排序	O(n)	O(n²)	O(n²)	O(1)	稳定
希尔排序	O(n^1.3)	O(n²)	O(n²)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
快速排序	O(nlogn)	O(n²)	O(nlogn)	O(nlogn)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
计数排序	O(n+k)	O(n+k)	O(n+k)	O(n+k)	稳定
桶排序	O(n)	O(n²)	O(n+k)	O(n+k)	稳定
基数排序	O(n*k)	O(n*k)	O(n*k)	O(n+k)	稳定