常见的十种排序算法C++实现（附时空复杂度，稳定性分析）

杨利霞

常见的十种排序算法C++实现（附时空复杂度，稳定性分析）

一、冒泡排序
思路：每一轮排序使得当前无序的部分的最大值冒到当前无序数组的末尾，下一轮中无序部分的长度等于上一轮减一，原数组的末端不断的变成有序的部分。
9 W" {0 \) E/ }: F( M. v
void bubble_sort(vector<int> &nums)
! `/ c) j3 q$ U, W{
0 d/ K/ b5 h- j* {    // 用于标记当前轮是否有交换发生
    bool swaped;
    // 从第一个数到倒数第二个数（n个数需要冒泡n-1次）
    for(int i = 0; i < nums.size() - 1; ++i)
    {
" e9 Y5 Z0 t. Q6 F; `2 M        swaped = false;
6 o/ W- H% p3 A' G        // 因为是当前的和后面的比，所以结束条件是一直到冒泡完毕的元素的前一个
$ F7 X/ G9 V4 j        for (int j = 0; j < nums.size()-1-i; ++j)
        {   
            // 通过交换两个元素，使得最大的冒到数组的末尾去，并且标记交换过
" s7 i6 C  M1 R$ r( M            // 若要从大到小排序，只需要把这个 '>' 改成 '<' 即可
            if (nums[j] > nums[j+1])
, m0 ^: ~5 J/ ?8 p# n% ?0 I, P            {
& ?8 d1 y6 B* y6 X! G9 h# i* S                int tmp = nums[j];
' j" a! t" c! }7 M! @) q1 H                nums[j] = nums[j+1];
                nums[j+1] = tmp;
7 p8 N% j- P; M: I" W                swaped = true;
            }
1 {% F1 f1 _# F9 E( V! k" r. U        }
        // 若该轮没有交换发生，说明数组已经有序，跳出循环
: J, A" E8 B. ?; C# m; {. c2 r; s6 x        if (!swaped)
            break;
    }
}

分析：时间复杂度最坏和平均情况是O()，最好的情况是已经有序所以是O(n)，空间复杂度O(1)，且因为两个相同的元素是不会交换位置的，因此是一种稳定的排序。
  [7 a1 o- L) p1 i0 z+ ^% H
二、选择排序
& f: Q2 ^: Q! b' h0 Z' r. i5 Z思路：每一轮都将未排序数组中最小的/最大的选择出来，然后与未排序数组的第一个交换。接着未排序数组的长度就应该减一，然后继续做这个操作，直到未排序数组的长度为1
! _3 C* D0 u6 G  J: P0 x0 p* B
2 g8 N; Y; B9 ?0 K+ {0 |void select_sort(vector<int> &nums)
% ]. d- T, m, n7 Y+ b, ?& O- |{   
; E& [# U- @6 ~- [$ }    // 用于存储每一轮中最小的数的下标
    int min_idx;
' X# l1 J; c4 I: B& S    // 循环从第一个数开始到倒数第二个数
6 H8 W. m. [1 C# _5 }. V    for(int i = 0; i < nums.size() - 1; ++i)
    {
3 J. ?4 R& I- L/ K) f        min_idx = i;
; d- G! `( N# J/ ^        // 在未排序部分寻找最小的数
: O; \( T' {7 Z0 c7 ^8 o: k6 t" j& |        for (int j = i+1; j < nums.size(); ++j)
# U/ Y( e* V, N0 S        {
* ]& N; w( U& N5 t( x( |            // 这里将 '<' 换成 '>' 就可以从大到小排序
: e+ d6 h6 W" O5 x. X+ W% n$ Q            if (nums[j] < nums[min_idx])
                min_idx = j;
        }
        // 将未排序部分最小的数与未排序部分的第一数交换位置
        int tmp = nums[min_idx];
, `$ ^# V$ [1 k: `0 P, K( g& B8 a        nums[min_idx] = nums;
        nums = tmp;
    }
- J  `5 Q8 _' z0 d8 s" N! ?% J- S( L}

分析：时间复杂度最坏、最好和平均情况都是O()，空间复杂度O(1)。因为每次选择最小元素要与未排序部分的第一个元素进行交换，因此可能会出现两个相同元素相对位置发生改变的情况，因此者是一种不稳定的排序。
; i6 G/ _; Q5 z" L% G7 j
三、插入排序
思路：从第二个元素作为当前位置，往前看，判断前面的元素是否大于当前位置，是的话就把前面的元素往后移动一个，依次类推，直到到了数组头或者碰到一个元素比当前元素小则循环终止，此时的位置就应该是当前位置元素的排序合适的位置。接着向后移动，把第三个元素作为当前位置，一直到最后一个元素。
4 m' I9 ~6 k8 p' t" f9 @+ J
void insert_sort(vector<int> &nums)
{
3 I( H2 L7 t/ ?2 L  m" X    // 从第二个元素到最后一个元素
    for(int i = 1; i < nums.size(); ++i)
: k5 c! |7 F& s7 {    {
! j  H; l* a" [& ~3 {$ ]        // tmp存下当前元素的值，将i赋给j
4 m; _3 ?* x) y; l+ o6 p        int tmp = nums;
        int j = i;
$ S* f) z" p7 G0 f. i0 p        // j从当前元素往前找，一直找到第二个元素位置
        for (; j > 0; j--)
        {
$ [7 E: N9 f$ D& g4 X0 S            // 判断tmp是否小于j-1位置的元素，是的话j-1的元素往后移动
& G8 D/ B  m7 o            // 要从大到小排序，只需要把 '<' 改为 '>' 即可
+ U4 d% m# m3 x, w4 W% ~8 X) f            if (tmp < nums[j-1])
  n" y) g7 f4 ]3 ~2 S% p                nums[j] = nums[j-1];
( [# t! w4 X* g# T* D2 \( [            // 否的话，j位置就应该是tmp的最终合适的位置
. n' S3 O) B8 z& |2 Z' _% t# w            else
                break;
        }
        // 将tmp赋给j位置的元素
! y" L$ K1 L1 T; x7 D! s        nums[j] = tmp;
    }
}
) p! F& M# O+ P
: Y8 O- o5 w, k+ ?; v9 ~分析： 时间复杂度最坏和平均情况都是O()，最好的情况是O(n)（最好情况就是已经有序，因此内层循环只需要判断一次就可以break），空间复杂度O(1)。因为是依次往前找的，元素移动也是相邻位置的移动，因此这个方法是稳定的。
' R- t3 I& w' u, t2 [6 a
# A- Z5 w2 V0 l9 q- j四、希尔排序
思路：希尔排序是插入排序的一种扩展，它不是一个的找然后插入。而是将与原数组根据间隔分成不同的组，比如十个数{1，2，3，4，5，6，7，8，9，10}可以设置gap为2，这样就分成了{1, 3, 5, 7, 9}和{2, 4, 6, 8, 10}两个组，分的组数就等于gap的数量，每组的包含的元素数量就等于数组的长度除以gap。通过这样操作，再最后gap为1的时候，数组就是基本有序的了，因此这时只需要很少的操作就可以将整个数组变为有序的。希尔排序gap的设置很关键，设置一组好的gap序列往往可以很大程度上提高希尔排序的效率
1 ~. M4 X9 U5 x! Y
void shell_sort(vector<int> &nums)
$ K5 W* U& N* m8 u{
8 @, U) u% q- F1 s    // 初始将gap设置为数组长度的一半，每次gap等于上次gap的一半，一直循环一直到gap等于1
# U5 ^' Q  `0 a; H3 n3 _# |1 a    for(int gap = nums.size()/2; gap > 0; gap/=2)
7 l* Y3 P3 p! s; ~/ P* D$ `( y+ L# U    {
        // 每一组的元素数量
        int ele_sz = nums.size() / gap;
3 F' i  ^" \3 }9 x0 ?# F  h* n        // 遍历每一组
        for (int i = 0; i < gap; ++i)
        {
            // 对每一个组进行插入排序，下面的代码和插入排序那基本一样
( k) H5 o. m+ D: e3 {' g( @            for (int j = 1; j < ele_sz; ++j)
# R$ B/ l( p0 Z& C9 b            {
  k8 ^4 x2 C. a                int tmp = nums[j*gap];
                int k = j;
                for (; k > 0; --k)
, g! J3 P0 k+ \4 n% X. ?- _; s                {
                    // 注意这里的下标要符合希尔排序间隔\
1 L2 n3 _: I3 n9 Y3 h  E                    // 要从大到小排序，只需要把 '<' 改为 '>' 即可
                    if (tmp < nums[(k-1)*gap])
                        nums[k*gap] = nums[(k-1)*gap];
                    else
* V# F1 f4 p5 Y0 a: b* e' }                        break;
                }
$ r" H* \" R6 ]! v  b                // 找到了最终插入的位置
                nums[k*gap] = tmp;
! q0 K. C% E* T3 E( g            }
! Y+ }. u. ?# \2 l        }
) a( x" a) q& {, S$ H        // 因为每次gap等于上次一半，当gap为1的时候就陷入死循环，所以这里设置一个判断用于跳出
        if (gap == 1)
            break;
    }
8 q, V( I7 b) ]2 M8 V! ~0 H% l}

分析：希尔排序最好情况的时间复杂度为O(nlogn)，而最坏情况和平均情况要根据它的增量序列来确定，好的增量序列可以把最坏情况的时间复杂度控制为O()。希尔排序是原地排序因此空间复杂度为O(1)。由于增量序列的存在，使得比较的元素存在间隔，因此就可能导致相同元素的相对位置发生改变，因此希尔排序是不稳定的。
6 m8 z: Z8 j$ L+ ^( c4 N
8 ]" n7 f6 k  E( Q+ n* l' ^五、归并排序
思路：归并排序是分治法的典型应用之一。首先先把大的数组拆分成两半，再继续拆，直到只剩一个数位置，拆完之后要合并，合并的时候就需要对两边的数进行排序，合并完成的时候就变成了有序的数组。以此类推，对左边的已经有序和右边已经有序的数组进行合并，最终得到了整体有序的数组。
% ~! |1 c( i6 ~" l: D8 i! ~0 L  M
& H" M( Y. v# u+ Z// 合的过程
, L: ]& {: N( q6 P  Gvector<int> merge_vec(vector<int> ivec1, vector<int> ivec2)
{
0 l: d2 l; U4 s( W) p) R$ v2 }    // 定义结果数组res, i和j分别用于遍历ivec1和ivec2
    vector<int> res;
7 Y# d+ u* g$ r% K% m    int i = 0, j = 0;
    // 当两个数组都没遍历到底
    while(i < ivec1.size() && j < ivec2.size())
    {
0 E# t* L: _9 Q4 X; _* R1 `+ I6 ?4 x        // 谁的当前数字小，谁就加入结果数组，并且下标后移
        // 这里将 '<' 改为 '>' 就可以从大到小排序
) T* ~3 N, v8 F  [" _. W, t7 |        if (ivec1 < ivec2[j])
! I  ?8 h! c+ n  l            res.push_back(ivec1[i++]);
2 V$ z& s/ z& d; s: _        else
            res.push_back(ivec2[j++]);
    }
    // 处理未遍历完的数组，直接全部加入最后面
& u3 U+ A2 A2 E- X4 u, k    while (j < ivec2.size())
        res.push_back(ivec2[j++]);
* E; U% {0 z0 [& {) U0 |6 ?8 T    while (i < ivec1.size())
        res.push_back(ivec1[i++]);
6 L0 }5 f* a" W2 z9 Z8 Z3 k    // 返回合并好的数组
5 d0 l8 Y, l4 w6 b    return res;
  d  |% j( \7 L9 r' d3 a}
6 `- E. N& u7 B/ B! T; e; L
// 分的过程
vector<int> merge_sort(vector<int> nums)
{
  Y  `$ y1 x* `) `; D" }5 A7 a    // 递归结束条件是只剩一个元素，则无序再分，直接返回
    if (nums.size() == 1)
        return nums;
. W4 U: C6 y- _. r+ e
    // 将大数组分治为左边的和右边的
" N3 ?  m# T! ?3 Z    vector<int> ivec1 = merge_sort(vector<int> (nums.begin(), nums.begin()+nums.size()/2));
1 q0 M# V. S' @2 w# w) c    vector<int> ivec2 = merge_sort(vector<int> (nums.begin()+nums.size()/2, nums.end()));
- v3 L, _9 j& D- h* z. T    // 返回合并后的大数组
9 K' J0 R: T/ j( m) w9 ?5 e    return merge_vec(ivec1, ivec2);
}
& ~/ ~  ?4 S" F5 ?; N$ G( h* @6 ^
分析：拆的过程时间复杂度是O(logn)，合的过程时间复杂度是O(n)，因此总的最好、最坏和平均时间复杂度是O(nlogn)。这种排序方法并非是原地排序，所以其空间复杂度是O(n)。这种方法并不会破坏相等元素之间的相对位置因此这是一种稳定的排序算法。

. j' N; r* J( v5 m: l六、快速排序
思路：快速排序同样也是利用分治法的思想，但是快速排序可以实现原地排序因此无序额外的空间。快速排序和归并排序的分的过程不同，快速排序分是根据小于和大于某个元素来分成两部分，而归并排序总是以中间的地方来划分。
9 _- E- T$ Y7 `: c  r
注意：算法中每一轮quicksort会确定一个元素的最终位置，我们递归处理这个元素左边的剩余数组和右边的剩余数组。lp和rp在走的时候，需要注意的只要rp指向的元素大于等于pivot就一直往左，lp指向的元素小于等于pivot就一直往右，若不加入等于这个判断条件可能就会在中途停下来而陷入死循环。而且pivot的选取也很关键，我们是以pivot大小来划分左右的，常见的方法可以以最左边或者最右边的元素作为pivot（但是这样在已经有序的数组中效率很差），或者随机选择pivot。

7 E! T9 K7 |5 N" k# }. k' U+ V+ Bvoid quicksort(vector<int> &nums, vector<int>::iterator lp, vector<int>::iterator rp)
6 j3 R# }+ |* \" B1 |+ h{
* G  M  Z8 v& n5 c/ Y    // 若左右相等，说明只有一个元素，就不需要排序
    if (rp - lp > 0)
' L- r3 Z4 v' I    {
+ B% h5 E& ~1 J' ]0 {7 w+ R        // old和orp存取起始位置和结束为止
        auto olp = lp, orp = rp;

. i; W" K+ X1 G$ l1 p8 F        // 下面两行代码可以要也可以去掉，其作用是随机选定一个范围在lp和rp之间的数作为pivot
* I3 m; P9 d% |# e! P( G. V) F        // 将这个数与最左边的数调换位置就可以通过*lp得到这个数
        int random = rand() % (rp - lp + 1);
/ v8 M( V$ a" l( o; R- I        swap(*lp, *(lp + random));
9 ?9 G  x0 j0 i2 {3 L
        int pivot = *lp;

        // 当lp和rp没遇到的时候
2 Y' ~/ v  r. q3 t        while (lp != rp)
: r3 o2 W/ V0 y, P* A# f; K( P        {
            // 只要rp指向的元素大于等于pivot而且lp和rp没遇到，rp自减
            // 将这里的 '>=' 换成 '<=' 并且把下面的 '<=' 换成 '>=' 就是从大到小
9 b" \* S' n5 A            while (*rp >= pivot && lp != rp)
                --rp;
0 o5 g0 \4 h$ C2 w            // 只要lp指向的元素小于等于pivot而且lp和rp没遇到，lp自增
            while (*lp <= pivot && lp != rp)
                ++lp;
            // 停下来的时候交换值
            swap(*lp, *rp);
7 P7 U3 ^$ U2 N        }

0 S6 H3 _+ A5 e        // lp遇到rp说明比pivot小的已经放在左边，比pivot大的已经放在右边了
6 @7 P) z5 T8 v- z7 k  @        // 因为while循环中rp先走，说明rp所指的元素一定是小于pivot或者正好是pivot
        // 因此需要交换二者的值，同时pivot就被放在了正确的排序位置上
( t5 ~8 d2 y$ q, a+ ]' \7 C! h        swap(*olp, *rp);
/ i- T' F3 _/ w1 ^5 g        // 递归处理pivot的左边和右边
        quicksort(nums, olp, lp-1);
& y# K5 J+ `! n5 w. v, T        quicksort(nums, rp+1, orp);
& Y% e, W0 D" \; X$ T    }
. k' Q' |7 }% v}
" p1 A/ n9 `$ {8 ]- e1 ~3 R1 P

void quick_sort(vector<int> &nums)
{
! M7 a4 M5 J9 r: g. Y    quicksort(nums, nums.begin(), nums.end()-1);
% b+ a6 m. J, {. F& \9 E}

分析：快速排序算法的时间复杂度分是O(logn)，治是O(n)，因此其最好和平均的复杂度是O(nlogn)。考虑一种情况，当数组有序而且我们选取pivot的方法是选最左边的或者最右边的元素时复杂度退化为O()。原地排序因此不需要额外空间，但是由于是递归函数，因此需要栈来保存状态，最好和平均情况下需要O(logn)，最坏的情况下需要O(n)。由于快速排序涉及到随机位置值的交换，因此快速排序是一种不稳定的排序方法。
, [+ f( g# |2 D% w: E+ }
! [" O# r# }  D5 k5 j( c" F7 `七、堆排序
思路：堆排序顾名思义需要一个堆，堆是一个完全二叉树，可以分为大顶堆和小顶堆，其中大顶堆是满足子节点的值小于父节点的堆，小顶堆是满足子节点的值大于父节点的堆。建好了堆之后我们就可以通过取堆顶元素再不断调整堆的方法来得到排序结果。因为堆是完全二叉树，因此其父节点和子节点的关系容易得到，所以我们可以用数组来模拟一棵树（一个堆），下面这个视频将堆排序讲的很清晰。
3 b$ Y1 g/ H6 h: w
( ^) `. a& G# u: b* l3 c8 K9 |% K* I【从堆的定义到优先队列、堆排序】 10分钟看懂必考的数据结构——堆_哔哩哔哩_bilibili

建堆：建立堆的方式可以分为从下往上和从上往下。以大顶堆为例，从下往上的话，对于每个父节点，判断其子节点值是否存在大于父节点的情况，是的话就交换这父节点和子节点的值，然后继续调整子节点（若子节点也存在节点的话则继续往下调整）。如果是从上往下建堆，就相当于是堆从从空的开始，不断插入元素再进行调整，判断当前插入的选择值是否大于其父节点的值，若是的话则交换当前节点与父节点，并继续向上调整直到无需调整或者到根节点。可以判断，从下往上的方式其时间复杂度为O(n)，而从上往下调整的方式其时间复杂度为O(nlogn)。同时需要注意的是，对于同一个数组，采用从下往上和从上往下的方式建立可能会导致节点的排列方式不一样，但是都满足大顶堆/小顶堆的性质。

& Z7 ~( P# @, m' P- W5 F1 S$ c下面是从下往上建大/小顶堆的代码：
5 V6 w' d4 |; E- @# p/ A) k' P$ X
// 接收参数为数组nums，当前调整节点下标i，当前堆的大小sz
void adjust_from_buttom(vector<int> &nums, int i, int sz)
& Y, \" l5 T7 k; w{
    // lpos和rpos分别代表左孩子和右孩子，largest用来存储左右孩子中较大的那个的下标
    // 建小顶堆需将largest改为minest，此时这个变量用于存储较小的元素
    int lpos = 2*i+1, rpos = 2*i+2, largest = i;
: w; f) M" X( n- n/ V8 U8 x6 D    // 若有左孩子（下标小于sz）而且左孩子数值大于当前节点数值，就记录下左孩子下标
! _7 \8 W' ^. l- j    // 建小顶堆需将 '>' 改为 '<'
    if (lpos < sz && nums[lpos] > nums)
9 x- W4 d; G9 ?0 B3 V' }. l  E        largest = lpos;
    // 若有右孩子（下标小于sz）而且右孩子数值大于最大的节点值，就记录下右孩子下标
* O: V7 t- L! x    // 建小顶堆需将 '>' 改为 '<'
, d. K, r4 u' ~    if (rpos < sz && nums[rpos] > nums[largest])
        largest = rpos;
    // 若存在某个孩子的值比当前值大
8 W0 W4 k: a# f  E: E    if (largest != i)
    {
        // 交换当前节点和较大的那个孩子的值
& T& f* I  t2 o& l" H/ g        swap(nums[largest], nums);
' N8 J7 j; }- O5 s1 ~        // 交换完之后继续往上调整树
        adjust_from_buttom(nums, largest, sz);
  \0 P% k$ F1 e8 o+ h' U& }( W7 z    }
}

void build_heap_from_buttom(vector<int> &nums)
' N6 }: H& m2 ~, `' ?, E{
    // 若数组只有一个元素则无需建立堆
2 r) ?, K# m+ U7 |    if (nums.size() != 1)
1 O% [/ }$ d" ~        // 从最后一个父节点开始循环，一直到根节点
: C* @; c, C- W" [- [- U        for (int i = nums.size()/2 -1; i >= 0; --i)
            // 不断对堆进行调整
            adjust(nums, i, nums.size());
/ @6 P, c1 r. L3 [( s% s: A}

- F$ u' p5 B, D+ m下面是从上往下建大/小顶堆的代码：
8 E* A) c: {1 S1 D% S
void adjust_from_top(vector<int> &nums, int i, int sz)
{
, V( B7 j+ S; L2 F, h* ~) z    // 如果i不等于0
    if (i)
& `2 d3 J' Q% x9 N' X: N( S; a9 l    {
2 u$ C2 Y, C& q. {9 {        // 若i为偶数，其父节点下标为i/2-1。若满足当前节点的值比父节点的值大
! ]" |$ G" H* _        // 建小顶堆需将 '>' 改为 '<'
9 s$ w) H; N3 C! ~6 \: o& u        if (!(i%2) && nums > nums[i/2-1])
$ L5 g" O9 K: _, Z/ D- H6 @+ \        {   
& _+ P/ y8 _7 Q- V: E3 {            // 交换当前节点与其父节点，再检查父节点需不需要调整
  E! }9 d1 c7 B2 Q9 n0 ^6 c8 @            swap(nums, nums[i/2-1]);
0 E% N9 o( R2 Z/ C1 {" }            adjust_from_top(nums, i/2-1, sz);
1 b+ g* |0 Y; P+ v2 X0 g' |" b5 o) }2 U        }
; S/ o! c: U9 d' ^- c+ ]        // 若i为奇数，其父节点下标为i/2，则当前节点比父节点的值大
        // 建小顶堆需将 '>' 改为 '<'
  U' o' q5 z6 k2 a6 y, z        if (i%2 && nums > nums[i/2])
7 r: _& }! `4 p  D        {
            // 交换当前节点与其父节点，再检查父节点需不需要调整
            swap(nums, nums[i/2]);
) D0 O+ D) L' `3 S) C, ]            adjust_from_top(nums, i/2, sz);
        }
! x0 {6 S# F* j    }
7 N4 X2 b$ A1 Z( g, P* ~  M}
4 X# u4 a$ s; ?8 K# }$ m8 I4 r
void build_heap_from_top(vector<int> &nums)
{   // 从第一个元素开始到最后一个元素结束
; M! a$ s5 a3 [! F    for (int i = 0; i < nums.size(); ++i)
        // 插入新的元素并调整
) T+ o5 n0 c1 ~1 r$ g        adjust_from_top(nums, i, i+1);
  O8 O) i) F6 P9 C- y: I& L}
% G% @6 s5 V6 M, F# z4 m
/ t( I- f  w* o9 A$ u/ m* U" e建立好的堆之后就可以通过取出堆的根节点，再不断调整堆来进行堆排序，我们可以把取出的节点与堆的最后一个节点进行交换，然后把堆的大小减一，这样就可以利用堆原有的空间来存储排序的结果，而无需额外开辟空间来存储。堆排序代码如下：

" y) U- E/ }, X# r% Z* w, ivoid heap_sort(vector<int> &nums)
{
0 }3 C9 k9 j$ B* j: F! I    build_heap_from_buttom(nums); // 或者是build_heap_from_buttom(nums);
    // 从最后一个节点开始往上走
+ L) [1 S) B( i    for(int i = nums.size()-1; i > 0; --i)
' C2 p& t! v/ ^2 y    {
        // 将最后一个节点与堆的根节点交换
" K9 j' w) H2 E% o) A4 ]4 E        swap(nums, nums[0]);
! d6 Q6 n5 ]; H        // 调整堆，堆的大小为原大小减一
# v  e7 \7 b3 X& D        adjust_from_buttom(nums, 0, i);
# `% W# b( \; b7 q% ^    }
}
我们可以注意到堆排序的过程交换了节点之后，只有根节点发生了改变，因此只有可能是根节点不满足堆的性质，所以在调整的时候我们调用了adjust_from_buttom()方法来堆根节点进行调整。

分析：堆排序的时间复杂度包括建堆和调整，从下往上建堆时间复杂度为O(n)，调整堆的时间复杂度为(logn)，因此堆排序最好、最坏和平均情况的时间复杂度为O(nlogn)。堆排序不需要额外的空间因此其空间复杂度为O(1)，但是由于建堆的过程中可能出现位置调整，因此堆排序是一种不稳定的排序方法。

八、计数排序
思路：计数排序主要是针对一定范围内的整数来进行了，先确定序列中的最大值和最小值，从而开辟max-min+1大小的空间，空间的每一个位置代表一个数，若遍历到了某个数就将该空间的计数值自增，那么遍历完原数组。排序结果可以通过遍历这个空间来得到。在实现上C++中可以通过map来实现这个操作，因为map本身是保证有序的。当然因为map内部要进去排序，所以如果要实现极致的空间换时间的话，需要自己手动来实现这样的map。
  o% F) F/ F0 a0 I! l
7 z6 F* L! x' f: e& y6 Yvoid count_sort(vector<int> &nums)
7 }5 e$ y9 x. ^{   
# x* ]! S4 c! L6 I* v8 W: G    // 用于存储数与出现次数的对应关系
5 {4 N" I2 P+ w7 P- v8 T! y$ P    map<int, int> cnt_map;
    // 遍历数组以将元素及出现次数添加进map
7 b1 k  l7 a6 C4 q    for (auto i : nums)
    {
% z$ c5 q; G$ w" Y: e& _        //
        if (cnt_map.find(i) == cnt_map.end())
; l" \2 A. a& Q3 T            cnt_map = 1;
+ ?, h9 d. B6 E( I        else
            ++cnt_map;
) P% f' h3 q) t. j5 M# J    }
' n! n$ {5 |$ r. j7 I) ?    // idx代表原数组下标
% m7 E8 \. b7 L2 O2 {+ P5 Q$ z    int idx = 0;
    // 遍历map以将map中的元素放回原数组
    for (auto it = cnt_map.begin(); it != cnt_map.end(); ++it)
, P  F6 Y5 u1 ^    {
        while (it->second != 0)
        {
            nums[idx++] = it->first;
6 [& @& ^2 x3 Z) f- U$ P6 X            --it->second;
        }
    }
0 R4 U8 v6 |/ |, k# P" d% O) R  B3 G}

分析：计数排序最好、最坏和平均情况下的时间复杂度都是O(n+k)，n是表示遍历原数组的时间，k（数据范围）是表示遍历辅助空间的时间，其空间复杂度为O(k)。计数排序可以看做是一种稳定的排序，比如我们把计数排序存储每个元素的位置看成队列，那么就符合先进先出，所以是稳定的。
9 q, h, ]* Y+ T1 e
$ C9 B9 s) x9 x) V* j" r4 W九、基数排序
5 ?2 D: L8 {( ?基数排序通常可以用在整数或字符串上，比如整数上就可以分0-9十个桶，通过比较个位，十位一直到最高位，分别把数装进相应的桶中，再依次取出，比较更高位再装进桶中，再取出，直到所有的数都在0这个桶中说明所有的数都排好序了。
. \" O' t1 g$ [" [
但是需要注意的是，一般的基数排序无法处理有负数的情况。针对负数，一般有两种解决方法：
  e' G1 ~+ v$ @2 h. p2 Q( T
  i- L$ ?' S$ n2 s5 x- L3 q1、另外开辟10个桶用来存储负数的情况（需要占用更多的空间）
: K% i4 Q! R- y
2、将所有元素变为正数再处理（可以将所有元素都加上最小负数的绝对值，但存在溢出风险），下面代码实现这种方式

void radix_sort(vector<int> &nums)
{
! b  r0 h5 {- \% M( P( D: I    // 开辟二维数组，第一维10代表十个桶，第二维当前为空
$ F5 h  q4 g9 b# M) u5 m    vector<vector<int>> ivec(10, vector<int>(0));
- H/ S% _# N9 Z" @1 I5 D    // 用于取出最小元素，将所有元素都变为正数
    int min_num = *min_element(nums.begin(), nums.end());
3 t4 h& U$ @! v0 H9 h# L$ z: f$ m    if (min_num < 0)
  h( t' G# C: |' k: [) q        for (auto &i : nums)
            i -= min_num;
  S, P$ N7 e2 u    // 用来控制比较的位数，初始为1代表比较个位数
* S* ^" p5 a% H" o- |; _8 V. Z7 [) K    int digit = 1;
    // 循环一直进行
    while (true)
! N8 ?0 Q5 G$ \( L1 N1 E) l; L& C7 h& g    {
! x5 a% L7 z; G( e9 [        // 对nums中所有元素遍历，将每个元素放入对应桶中
        for(auto i : nums)
! Y. _2 u" m2 a5 A" {8 y. I            ivec[i%(digit*10)/digit].push_back(i);

* e# P4 X6 k& K% m, u        // 这是循环终止条件，即所有元素都在0号桶中
        if (ivec[0].size() == nums.size())
            break;
9 T( ~! n9 S2 G; D! ]        // 记录nums中的下标用于放回nums中
        int idx = 0;
7 r' R: `1 N+ ~* B        // 依次从每个桶中拿出元素放回nums，取完之后清空桶
, H5 f8 K( {+ X" a! e; \# i        for (int i = 0; i < 10; ++i)
0 q) h. c; C, D# Y' g        {
+ p7 e: i  R6 U/ @# m            for(int j = 0; j < ivec.size(); ++j)
7 O, T+ M# `. H2 v# t5 g8 K4 X                nums[idx++] = ivec[j];
, D. J4 v$ f2 H; j" c/ }9 S, E; ^            ivec.clear();
        }
" n. Y# f# t$ c9 ^        // 下一次循环比较更高位
        digit *= 10;
/ C% L$ T4 ]2 X5 Q6 l  x/ h% C    }
4 W4 E: ]: N0 H    // 排序完毕后将元素恢复为初始值
  Z% r$ N) ]: S! I, @+ W    if (min_num < 0)
, s( \8 J: \9 s" _& Q$ X$ p        for (auto &i : nums)
            i += min_num;
8 u% h1 `! n0 e/ ?}
1 E$ E/ ]& R+ V2 t* x2 `, k9 E8 \
; ?- V, F8 J1 `4 }& e1 s  v分析：基数排序的时间复杂度取决于待排序的元素中的最大位数k，如最大元素为1023，那么最大位数k=4。对于每一位我们需要遍历两遍数组，但是这里的两遍可以省略，因此最好、最坏和平均的时间复杂度都是O(k*n)。由于我们需要开辟一个额外的空间来把每个数放入桶中，因此空间复杂度为O(n)。又因为我们放入桶和从桶中拿出的操作都保证了先进先出，因此基数排序是一种稳定的排序方法。
$ a& o9 b. B9 o
. Y- Q2 F% V+ L! `1 n; a" W% F十、桶排序
前面计数排序和基数排序都是桶排序的一种特例。桶排序是这样一种排序，它将原来的数组分到不同的桶里，再分别对每个桶内部采用排序算法进行排序（可以用快排、可以用选择、冒泡等都没问题），最后将每个桶里的元素依次取出就得到了排好序的结果。因此桶排序如何分桶是一个关键的问题，如果分的好的话，每个桶都能均匀地承载一部分数据，最后时间复杂度就会比较理想。若果分的不好，很多数据都集中在一个桶里，那么最后的时间复杂度就很差（最差情况下会略大于桶内排序算法的效率），此外桶排序还需要额外的空间。

void bucket_sort(vector<int> &nums, int bucket_cnt)
+ |7 ]2 v. _$ k% |% Z2 D# g+ T5 m5 E{
" Z9 u8 f0 Z* [, B3 A5 p$ J    // 建立bucket_cnt个桶，每个桶初始为空
$ [) U. `8 h! O% s- E6 C6 }6 d    vector<vector<int>> ivec(bucket_cnt, vector<int>(0));
$ M7 H! a" O+ L4 `8 M8 F4 M* `( _    // 拿出数组中最大和最小的元素来确定每个桶之间的间隔
- E2 L& h% H$ s  ^    int min_ele = *min_element(nums.begin(), nums.end());
* Y2 r0 G8 z$ b/ ?5 c2 H& `    int max_ele = *max_element(nums.begin(), nums.end());
9 U& W$ b: \. `8 G) r" ~    int gap = (max_ele - min_ele) / bucket_cnt;
    // 如果间隔比桶个数都小，那么直接排序可能更快
2 f' C- m9 B. k$ K+ }, i    if (gap > bucket_cnt)
. V9 x% O# R$ i4 Q5 M0 b    {
! Y) S7 `* d# N        // 遍历数组中每个元素
        for (auto i : nums)
        {
& q. H2 T+ J7 }% p3 g: M            // 确定元素所在的桶序号
            int bucket_num = (i-min_ele)/gap;
  {  G7 ?) w  T8 n- m- \            // 若算出的序号等于桶个数，那么说明越界了（比如数组中最大元素就会出现这样的情况）
            if (bucket_num == bucket_cnt)
$ R4 v$ Z0 I$ B- V! J7 x% \8 T# D                --bucket_num;
- \$ a8 m& p, r, s8 {5 f            // 将该元素装入桶中
: o. F9 ^' R$ P# ]3 m            ivec[bucket_num].push_back(i);
        }
        // idx记录原数组nums中的下标用于装回元素
& o# g* O: v& B1 U) X7 P        int idx = 0;
        // 对每个桶先排序再往nums中装入元素，最后清空桶
3 q7 p; M# _! e; c2 C) L        for (auto &vec : ivec)
) S0 q) M. {" D# L! D        {
6 g& |* z) [1 L& e- W            quick_sort(vec);
            for (const auto ele : vec)
' X' z$ t4 [, B8 e* E, _                nums[idx++] = ele;
- B$ h# ?4 b5 w9 T/ O8 v. y            vec.clear();
) k- g  n2 L* g* W5 y        }
4 _$ `( i# {& C2 P/ e: C0 w( h    }
    // 直接排序
    else
  @9 c8 |5 a2 ?+ s        quick_sort(nums);
}

分析：桶排序将原数组分为k个桶来处理，假设数组总数为n，那么每个桶装了n/k个数据，假设我们在桶的内部使用快速排序，其时间复杂度为O(klogk)，那么对于所有桶来说，总的时间复杂度就是k*O((n/k)*log(n/k)) = O(n*log(n/k))。最好的情况是每个数据都装进一个桶，这样就无需排序了，因此最好的时间复杂度是O(n)，平均情况的时间复杂度是O(n*log(n/k))，最坏的情况的可以接近O(nlogn)，但是比O(nlogn)要更差（因为存在分桶等操作）。桶排序的空间复杂度是O(n+k)，因为桶排序除了要装下原始数组长度的元素，还需要额外的k个桶，这k个桶系统会默认分配内存。桶排序是否稳定依赖于其内部的排序算法，若内部使用快排则不稳定，若内部使用归并则是稳定的。
————————————————
3 ]2 F: R1 s1 ^% d. Z版权声明：本文为CSDN博主「Xaiver_97」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
+ o) i0 O* {9 q7 X7 r原文链接：https://blog.csdn.net/Xavier_97/article/details/126722423
, t+ f% j( ^9 G3 m* H" j2 ]) a

- {. q$ j0 n, y! A1 i