Python C\C++ Java 手写十大经典排序算法冒泡、选择、插入、希尔、归并、快速、堆、计数、桶、基数排序

本文链接：https://blog.csdn.net/weixin_41738030/article/details/104444038

Python C\C++ Java 手写十大经典排序算法冒泡、选择、插入、希尔、归并、快速、堆、计数、桶、基数排序

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：
在这里插入图片描述

关于时间复杂度：

平方阶 $O (n 2)$ 排序各类简单排序：直接插入、直接选择和冒泡排序。
线性对数阶 $O (n l o g 2 n)$ 排序快速排序、堆排序和归并排序；
$O (n 1 + §))$ 排序， $§$ 是介于 0 和 1 之间的常数。希尔排序
线性阶 $O (n)$ 排序基数排序，此外还有桶、箱排序。

关于稳定性：

排序后 2 个相等键值的顺序和排序之前它们的顺序相同
稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释：

n：数据规模
k：“桶”的个数
In-place：占用常数内存，不占用额外内存
Out-place：占用额外内存

C++代码数据

#include <iostream>
#include <cstdio>
#include <cstdlib>

typedef int KeyType;
typedef struct {
    KeyType key;
}RecordType, RcdType;

typedef struct {
    RcdType * rcd;  //  存储空间基址
    int length;     //  当前长度
    int size;       //  存储容量
}RcdSqList;         //  记录的顺序表

void InsertSort(RcdSqList &L);                  //  直接插入排序
void ShellInsert(RcdSqList &L, int dk);         //  一趟希尔排序
void ShellSort(RcdSqList &L, int d[], int t);   //  希尔排序
int BinSearch(RcdSqList &L, KeyType, int low, int high);    //  递归实现折半查找
void Merge(RcdType SR[], RcdType TR[], int i, int m, int n);  //  2-路归并
void MSort(RcdType R1[], RcdType R2[], int i, int left, int right);    //  递归归并排序
void MergeSort(RcdSqList &L);     //  对顺序表L作2-路归并排序
int Partition(RcdType rcd[], int low, int high);    //  划分算法
void QSort(RcdType rcd[], int s, int t);    //  快速排序
void QuickSort(RcdSqList &L);   //  对记录的顺序表L进行快速排序

Python 数据

def main():
    arr = [1, 3, 2, 0, 5]
    print(RadixSort(arr))


if __name__ == '__main__':
    main()

C++ 测试代码

int main() {
    std::cout << "Hello, World!" << std::endl;
    printf("Hello, World!\n");
    RcdType sample[50] = {5, 9, 1, 2, 7, 6, 3, 4, 0, 8};
    RcdType sample1[50] = {0, 5, 9, 1, 2, 7, 6, 3, 4, 0, 8};
    for (int i = 0; i < 10; ++i) {
        printf("%d  ", sample[i]);
    }
    printf("\n");
    RcdSqList L;
    L.length = 10;
    L.size = 50;
    L.rcd = sample1;
    printf("InsertSort:\n");
    InsertSort(L);
    for (int i = 1; i < 11; ++i) {
        printf("%d  ", sample1[i]);
    }
    printf("\n");

    printf("ShellSort:\n");
    int d[5] = {3, 1};
    L.rcd = sample;
    ShellSort(L, d, 2);
    for (int i = 1; i < 11; ++i) {
        printf("%d  ", sample1[i]);
    }
    printf("\n");

    printf("BinSearch:\n");
    printf("%d\n", BinSearch(L, 4, 0, 9));
    printf("%d\n", L.rcd[9]);

    RcdType sample2[50] = {5, 9, 1, 2, 7, 6, 3, 4, 0, 8};
    L.rcd = sample2;
    printf("MergeSort:\n");
    MergeSort(L);
    for (int i = 1; i < 11; ++i) {
        printf("%d  ", L.rcd[i].key);
    }
    printf("\n");

    return 0;
}

1、冒泡排序

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

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

（1）算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

（2）动图演示

在这里插入图片描述

（3）Python 代码

def bubbleSort(arr: list):
    """
    冒泡排序，对第二个到最后一个数，逐次遍历前面的数字大小对换
    :rtype: 排序后的数组，list
    """
    for i in range(1, len(arr)):
        for j in range(0, len(arr) - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

（4）C++ 代码

void BubbleSort(RcdSqList &L) {
    int i, j;
    for (i = 1; i < L.length; ++i) {
        for (j = 0; j < L.length - i; ++j) {
            if (L.rcd[j].key > L.rcd[j + 1].key) {
                KeyType tmp = L.rcd[j].key;
                L.rcd[j] = L.rcd[j + 1];
                L.rcd[j + 1].key = tmp;
            }
        }
    }
}

2、选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是 $O(n^2)$ 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

（1）算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。

（2）动图演示

在这里插入图片描述

（3）Python 代码

def selectionSort(arr):
    """
    选择排序：对除了最后一个数的每个数，逐个遍历后面的数字找到最小的数字
    :rtype: 排序后的数组，list
    """
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr

（4）C++ 代码

//  选择排序
void SelectSort(RcdSqList &L) {
    int i, j;
    for (i = 0; i < L.length - 1; ++i) {
        // 记录最小数的索引
        int minIndex = i;
        for (j = i + 1; j < L.length; ++j) {
            if (L.rcd[j].key < L.rcd[minIndex].key) {
                minIndex = j;
            }
        }
        //  i 不是最小数时，将i和最小数进行交换
        if (i != minIndex) {
            KeyType tmp = L.rcd[i].key;
            L.rcd[i].key = L.rcd[minIndex].key;
            L.rcd[minIndex].key = tmp;
        }
    }
}

3、插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

（1）算法步骤

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

（2）动图演示

在这里插入图片描述

（3）Python 代码

def insertionSort(arr):
    """
    插入排序：对数组中的每个数，逐个往前遍历，如果比其大，则后移，
    直到找到比其小，则有空位插入。
    :rtype: 排序后的数组，list
    """
    for i in range(len(arr)):
        preIndex = i - 1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex + 1] = arr[preIndex]
            preIndex -= 1
        arr[preIndex + 1] = current
    return arr

（4）C\C++代码

//  直接插入排序
void InsertSort(RcdSqList &L) {
    int i, j;
    for (i = 1; i < L.length; ++i) {
        if (L.rcd[i + 1].key < L.rcd[i].key) { //  需将L.rcd[i+1]插入有序序列
            L.rcd[0] = L.rcd[i + 1];
            j = i + 1;
            do {
                j--;
                L.rcd[j + 1] = L.rcd[j];      //  记录后移
            } while (L.rcd[0].key < L.rcd[j - 1].key); //  判断是否需要继续移动
            L.rcd[j] = L.rcd[0];    //  插入
        }
    }
}

package schedule.job.algorithm;

import schedule.job.model.Job;
import schedule.process.model.Process;

public class InsertSort {
    // 采用插入排序对所有的进程进行排序
    public static void insertSort(Job[] jobs)
    {
        int i, j;
        int n = jobs.length;
        Job target;
        for (i = 1; i < n; i++)
        {
            j = i;
            target = jobs[i];
            while (j > 0 && target.arrivalTime < jobs[j - 1].arrivalTime)
            {
                jobs[j] = jobs[j - 1];
                j--;
            }
            jobs[j] = target;
        }
    }
}

4、希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

（1）算法步骤

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

（2）Python 代码

def shellSort(arr):
    """
    希尔排序：对待排序的数组分割成若干个子序直接进行直接插入排序，
    待整个数组的记录“基本有序”时，再对全体记录进行依次直接插入排序。
    :rtype: 排序后的数组，list
    """
    import math
    gap = 1
    while gap < len(arr) / 3:
        gap = gap * 3 + 1
    while gap > 0:
        for i in range(gap, len(arr)):
            temp = arr[i]
            j = i - gap
            while j >= 0 and arr[j] > temp:
                arr[j + gap] = arr[j]
                j -= gap
            arr[j + gap] = temp
        gap = math.floor(gap / 3)   # floor() 返回数字的下舍整数
    return arr

（4）C\C++代码

//  一趟希尔排序
void ShellInsert(RcdSqList &L, int dk) {
    //  对顺序表L作一趟希尔排序，增量为dk
    int i, j;
    for (i = 0; i <= L.length; ++i) {
        if (L.rcd[i + dk].key < L.rcd[i].key) {    //  需将L.rcd[i+dk]插入有序序列
            L.rcd[0] = L.rcd[i + dk];     //  暂存在L.rcd[0]
            j = i + dk;
            do {
                j -= dk;
                L.rcd[j + dk] = L.rcd[j]; //  记录后移
            } while (j - dk > 0 && L.rcd[0].key < L.rcd[j - dk].key);  //  是否继续移动
            L.rcd[j] = L.rcd[0];    //  插入
        }
    }
}

//  希尔排序
void ShellSort(RcdSqList &L, int d[], int t) {
    //  按增量序列d[0...t-1]对顺序表L作希尔排序
    for (int i = 0; i < t; ++i) {
        ShellInsert(L, d[i]);
    }
}

5、归并排序

图解归并排序 C Java实现详细介绍：https://blog.csdn.net/weixin_41738030/article/details/89532490
在这里插入图片描述

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）
自下而上的迭代

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

（1）算法步骤

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
设定两个指针，最初位置分别为两个已经排序序列的起始位置；
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
重复步骤 3 直到某一指针达到序列尾；
将另一序列剩下的所有元素直接复制到合并序列尾。

（2）动图演示

在这里插入图片描述

（3）Python 代码

def mergeSort(arr):
    """
    归并排序：对数据逐次递归拆成两份
    :rtype: 返回排序后的数组，这里递归左右两个数组
    """
    import math
    if len(arr) < 2:
        return arr
    middle = math.floor(len(arr) / 2)
    left, right = arr[0: middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))


def merge(left, right):
    """
    对左右两个序列进行排除合并
    :rtype: 排序后的数组
    """
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    while left:
        result.append(left.pop(0))
    while right:
        result.append(right.pop(0))
    return result

（4）C\C++代码

//  2-路归并
void Merge(RcdType SR[], RcdType TR[], int i, int m, int n) {
    //  将相邻的有序区间SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
    int k, j;   //  i是最左边向右,j是中间向右，k是新数组整体从左到右填写
    for (j = m + 1, k = i; i <= m && j <= n; ++k) {
        //  将SR中记录按关键字从小到大地复制到TR中
        if (SR[i].key <= SR[j].key) //  "<="归并排序稳定，"<"归并排序不稳定
            TR[k] = SR[i++];
        else
            TR[k] = SR[j++];
    }
    while (i <= m) TR[k++] = SR[i++];   //  将剩余的SR[i..m]复制到TR
    while (j <= n) TR[k++] = SR[j++];   //  将剩余的SR[j..n]复制到TR
}

//  递归归并排序
void MSort(RcdType R1[], RcdType R2[], int i, int left, int right) {
    //  对R1[left..right]归并排序，若i % 2 == 1,则排序后的记录存入R2[left..right],否则存入R1[left..right]
    int middle;
    if (left == right) {
        if (i % 2)
            R2[left] = R1[left];
    } else {
        middle = (left + right) / 2;   //  将区间[left..right]平分为[left..m]和[m+1..right]
        MSort(R1, R2, i + 1, left, middle);    //  对区间[left..m]递归
        MSort(R1, R2, i + 1, middle + 1, right);//  对区间[m+1..right]递归
        if (i % 2)  //  将R1[left..m]和R1[m+1..right]归并到R2[left..right]
            Merge(R1, R2, left, middle, right);
        else        //  将R2[left..m]和R2[m+1..right]归并到R1[left..right]
            Merge(R2, R1, left, middle, right);
    }
}

//  对顺序表L作2-路归并排序
void MergeSort(RcdSqList &L) {
    RcdType *R;
    R = (RcdType *) malloc((L.length + 1) * sizeof(RcdType));   //  分配辅助空间
    MSort(L.rcd, R, 0, 1, L.length);        //  对L.rcd[1..L.length]归并排序
    free(R);
}

（5）Java 代码

package sortdemo;

import java.util.Arrays;

/**
 * Created by chengxiao on 2016/12/8.
 */
public class MergeSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        sort(arr,0,arr.length-1,temp);
    }
    private static void sort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

6、快速排序

快速排序算法详细教程及其优化，C语言代码详细介绍：https://blog.csdn.net/weixin_41738030/article/details/89409311
在这里插入图片描述
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 $n$ 个项目要 $Ο(n\log n)$ 次比较。在最坏状况下则需要 $Ο(n^2)$ 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 $Ο(n\log n)$ 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 $O(n^2)$ ，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 $\log n)$ 的排序算法表现要更好，可是这是为什么呢，我也不知道。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：

快速排序的最坏运行情况是 $O(n^2)$ ，比如说顺序数列的快排。但它的平摊期望时间是 $O(n\log n)$ ，且 $O(n\log n)$ 记号中隐含的常数因子很小，比复杂度稳定等于 $O(n\log n)$ 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

（1）算法步骤

从数列中挑出一个元素，称为 “基准”（pivot）;
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

（2）动图演示

在这里插入图片描述

（3）Python 代码写法1

def Qsort_main(arr):
    return QSort(arr, 0, len(arr) - 1)


def QSort(arr, left, right):
    """
    快速排序：从数据中找到基准，比基准小的放在基准前面，比基准大的放基准后面
    :rtype: object
    """
    if left < right:
        privotloc = QSort_partitaion(arr, left, right)
        QSort(arr, left, privotloc - 1)
        QSort(arr, privotloc + 1, right)
    return arr


def QSort_partitaion(arr, low, high):
    """
    快速排序基准划分，返回基准
    :rtype: object
    """
    if low > high:
        return -1
    tmp = arr[low]
    while low < high:
        while low < high and arr[high] >= tmp:
            high -= 1
        arr[low] = arr[high]
        while low < high and arr[low] <= tmp:
            low += 1
        arr[high] = arr[low]
    arr[low] = tmp
    return low

（3）Python 代码写法2

def quickSort(arr, left=None, right=None):
    """
    快速排序：从数据中找到基准，比基准小的放在基准前面，比基准大的放在基准后面
    :rtype: 排序后的数组
    """
    left = 0 if not isinstance(left, (int, float)) else left
    right = len(arr) - 1 if not isinstance(right, (int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex - 1)
        quickSort(arr, partitionIndex + 1, right)
    return arr


def partition(arr, left, right):
    """
    快速排序，基准划分
    :rtype: int,基准序号
    """
    pivot = left
    index = pivot + 1
    i = index
    while i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index += 1
        i += 1
    swap(arr, pivot, index - 1)
    return index - 1


def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

（4）C\C++代码

//  划分算法
int Partition(RcdType rcd[], int low, int high){
    //  对子序列rcd[low..high]进行一次划分，并返回枢轴应当所处的位置
    //  使得在枢轴之前的关键字均不大于它的关键字，枢轴之后的关键字均不小于它的关键字
    rcd[0] = rcd[low];      //  将枢轴移至数组的闲置单元
    while (low < high){     //  low和high从待排序列的两端交替地向中间移动
        while (low < high && rcd[high].key >= rcd[0].key)   --high;
        rcd[low] = rcd[high];   //  将比枢轴关键字小得关键字移至低端
        while (low < high && rcd[low].key <= rcd[0].key)    ++low;
        rcd[high] = rcd[low];   //  将比枢轴关键字打的关键字移至高端
    }
    rcd[low] = rcd[0];  //  枢轴关键字移到正确位置
    return low;         //  返回枢轴的位置
}

//  快速排序
void QSort(RcdType rcd[], int s, int t){
    //  对记录序列rcd[s..t]进行快速排序
    int privotloc;
    if (s < t){         //  长度大于1
        privotloc = Partition(rcd, s, t);   //  对rcd[s..t]进行划分并返回枢轴位置
        QSort(rcd, s, privotloc - 1);       //  对枢轴之前的子序列递归快排
        QSort(rcd, privotloc + 1, t);       //  对枢轴之后的子序列递归快排
    }
}

//  对记录的顺序表L进行快速排序
void QuickSort(RcdSqList &L){
    QSort(L.rcd, 1, L.length);
}

7、堆排序

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

大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 $Ο(n\log n)$ 。

（1）算法步骤

创建一个堆 H[0……n-1]；
把堆首（最大值）和堆尾互换；
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
重复步骤 2，直到堆的尺寸为 1。

（2）动图演示

在这里插入图片描述

Python 代码

def buildMaxHeap(arr):
    import math
    for i in range(math.floor(len(arr) / 2), -1, -1):
        heapify(arr, i)


def heapify(arr, i):
    left = 2 * i + 1
    right = 2 * i + 2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        swap(arr, i, largest)
        heapify(arr, largest)


def heapSort(arr):
    """
    堆排序：建立堆
    :rtype: object
    """
    global arrLen
    arrLen = len(arr)
    buildMaxHeap(arr)
    for i in range(len(arr) - 1, 0, -1):
        swap(arr, 0, i)
        arrLen -= 1
        heapify(arr, 0)
    return arr

8、计数排序

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

（1）动图演示

在这里插入图片描述

（2）Python 代码

def countingSort(arr):
    """
    计数排序：将输入的数据值转化为健存储在额外开辟的数组空间
    :rtype: 排序后的数组
    """
    maxValue = max(arr)
    bucketLen = maxValue + 1
    bucket = [0] * bucketLen
    sortedIndex = 0
    arrLen = len(arr)
    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]] = 0
        bucket[arr[i]] += 1
    for j in range(bucketLen):
        while bucket[j] > 0:
            arr[sortedIndex] = j
            sortedIndex += 1
            bucket[j] -= 1
    return arr

9、桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

在额外空间充足的情况下，尽量增大桶的数量
使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

什么时候最快

当输入的数据可以均匀的分配到每一个桶中。

什么时候最慢

当输入的数据被分配到了同一个桶中。

Python 代码

def bucketSort(arr):
    """
    桶排序
    :rtype: 排序好的数组，list
    """
    minNum = min(arr)
    maxNum = max(arr)
    # 桶的大小
    bucketRange = (maxNum - minNum) / len(arr)
    # 桶数组
    countList = [[] for i in range(len(arr) + 1)]
    # 向桶数组填数
    for i in arr:
        countList[int((i - minNum) // bucketRange)].append(i)
    arr.clear()
    # 回填，这里桶内部排序直接调用了sorted
    for i in countList:
        for j in sorted(i):
            arr.append(j)
    return arr

10、基数排序

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法：

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

基数排序：根据键值的每位数字来分配桶；
计数排序：每个桶只存储单一键值；
桶排序：每个桶存储一定范围的数值；

动图演示

在这里插入图片描述

Python 代码

def RadixSort(arr):
    i = 0  # 初始为个位排序
    n = 1  # 最小的位数置为1（包含0）
    maxNum = max(arr)  # 得到带排序数组中最大数
    while maxNum > 10 ** n:  # 得到最大数是几位数
        n += 1
    while i < n:
        bucket = {}  # 用字典构建桶
        for x in range(10):
            bucket.setdefault(x, [])  # 将每个桶置空
        for x in arr:  # 对每一位进行排序
            radix = int((x / (10 ** i)) % 10)  # 得到每位的基数
            bucket[radix].append(x)  # 将对应的数组元素加入到相应位基数的桶中
        j = 0
        for k in range(10):
            if len(bucket[k]) != 0:  # 若桶不为空
                for y in bucket[k]:  # 将该桶中每个元素
                    arr[j] = y  # 放回到数组中
                    j += 1
        i += 1
    return arr