数据结构与算法（五）排序算法篇

杨利霞

数据结构与算法（五）排序算法篇
, q4 i8 T# d) [
& v, a/ @1 S, W# b( G' B排序算法篇
恭喜各位小伙伴来到最后一部分：排序算法篇，数据结构与算法的学习也接近尾声了，坚持就是胜利啊！
) g- C9 ?& D# L* @4 }* l! K6 Z
& w9 D5 P& l5 e" a# a$ ^* V/ O一个数组中的数据原本是凌乱的，但是由于需要，我们需要使其有序排列，要实现对数组进行排序我们之前已经在C语言程序设计篇中讲解过冒泡排序和快速排序（选学），而这一部分，我们将继续讲解更多种类型的排序算法。

  S% u" J+ V" C/ ?" K在开始之前，我们还是从冒泡排序开始回顾。
$ R  v. V! q( V- i
) O1 i. w6 v* h基础排序
2 ^, o- j  R) b: y+ p& H- N冒泡排序
- I; h- r4 g' @3 m5 ?冒泡排序在C语言程序设计篇已经讲解过了，冒泡排序的核心就是交换，通过不断地进行交换，一点一点将大的元素推向一端，每一轮都会有一个最大的元素排到对应的位置上，最后形成有序。算法演示网站：https://visualgo.net/zh/sorting?slide=2-2

( D6 a, G: ]/ l# m' @设数组长度为N，详细过程为：

4 U- d, ]" t4 @共进行N轮排序。
每一轮排序从数组的最左边开始，两两元素进行比较，如果左边元素大于右边的元素，那么就交换两个元素的位置，否则不变。
每轮排序都会将剩余元素中最大的一个推到最右边，下次排序就不再考虑这些已经在对应位置的元素。
3 z: [, I' H0 g比如下面的数组：

# o) [4 D& H. t8 N% `
: s; N0 C$ W* j( Q. a8 D( s
那么在第一轮排序时，首先比较前两个元素：
4 j6 F/ g; ^+ S& k& c5 B6 d


我们发现前者更大，那么此时就需要交换，交换之后，继续向后比较后面的两个元素：
/ A3 Y" M% W9 D' c( l' C7 |
( l3 e# S: d; [

我们发现后者更大，不变，继续看后两个：
# P6 J3 n2 w1 m: }: x, E: d: a5 \
4 o3 G" r3 S0 D, P' i/ R2 r
; F1 U* v& Q/ x6 Y- e: Z
8 [) X/ s2 f3 N2 E此时前者更大，交换，继续比较后续元素：

& F; S- k* `- h& V' x
5 O+ [2 G. _% g7 ~/ ~) s
还是后者更大，继续交换，然后向后比较：

3 K; w. U5 l/ W# F

依然是后者更大，我们发现，只要是最大的元素，它会在每次比较中被一直往后丢：
7 K, N% H1 ?+ t* _; I


# n0 q- T- N1 u) P最后，当前数组中最大的元素就被丢到最前面去了，这一轮排序结束，因为最大的已经排到对应的位置上了，所以说第二轮我们只需要考虑其之前的这些元素即可：


* h2 k( X% {. a( D
0 C7 i2 ?0 M3 Y# T这样，我们就可以不断将最大的丢到最右边了，最后N轮排序之后，就是一个有序的数组了。
8 I& C- o& M: m
) D* P$ ]  p- }3 D) F4 ?程序代码如下：

void bubbleSort(int arr[], int size){
) j5 _! R, U' g. F' t! T    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size - i - 1; ++j) {
$ D! t; G8 H! X( y8 n/ S% A3 S            //注意需要到N-1的位置就停止，因为要比较j和j+1
; E$ m! _5 G# K! W. a: w# u            //这里减去的i也就是已经排好的不需要考虑了
9 w8 |( s  }$ ^) i7 K& d            if(arr[j] > arr[j + 1]) {   //如果后面比前面的小，那么就交换
% j! x% |1 \: y! V, v; }  l                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
' `, v- h. C# C" V% e            }
        }
, T/ c, P+ D' ^* r: {# k    }
% x0 A4 |0 Y3 s* T: [6 g}
1
2
, D0 t* ?/ _- B- b. \3 x3
) y! ~2 c3 ?9 W: ?4
5
6
7
: O1 I1 M! b5 @* q8
) ^0 ?- }6 \0 W) a3 A8 P8 I/ E# {3 E9
10
11
; I8 E- \9 W# d8 Y+ N/ h12
9 X. ^! ?' n  K- q2 R7 Z13
/ N$ Z; S( F6 O6 D( {1 S8 n9 y只不过这种代码还是最原始的冒泡排序，我们可以对其进行优化：

实际上排序并不需要N轮，而是N-1轮即可，因为最后一轮只有一个元素未排序了，相当于已经排序了，所以说不需要再考虑了。
如果整轮排序中都没有出现任何的交换，那么说明数组已经是有序的了，不存在前一个比后一个大的情况。
所以，我们来改进一下：

/ ]3 Q/ Y, _% |$ T# Uvoid bubbleSort(int arr[], int size){
3 T1 H" q% l9 v) q6 v: k    for (int i = 0; i < size - 1; ++i) {   //只需要size-1次即可
1 Q3 h9 i! ?# @3 @6 G1 e* Y        _Bool flag = 1;   //这里使用一个标记，默认为1表示数组是有序的
& P' a- g, `7 H+ B4 C0 u% y- B9 X        for (int j = 0; j < size - i - 1; ++j) {
            if(arr[j] > arr[j + 1]) {
* I! K  ], A4 S) |2 Q" A2 }1 s                flag = 0;    //如果发生交换，说明不是有序的，把标记变成0
* M9 w) }3 V$ U0 Y/ ]# \                int tmp = arr[j];
. ~9 R% y( S% f; i) w. Y8 R                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
        if(flag) break;   //如果没有发生任何交换，flag一定是1，数组已经有序，所以说直接结束战斗
    }
, O; y6 O3 P, u& G! }+ b6 q9 G}
  T* X0 G% x& A6 w0 n6 U1
5 G) K$ A4 W2 G6 X# S2
' W3 n/ U' |# @/ Q3
4
* h" o  S) P) j& r; |+ g5
  T+ E. f5 y$ \( G& i! x; l1 x5 H) x6
7
8
9
10
11
12
0 v: [. v- d2 X9 j' [13
3 i+ O* p& p9 ]0 f5 A14
6 T3 Y/ }3 i+ k* ~% }/ ?  v, I* x这样，我们才算编写完了一个优化版的冒泡排序。
3 g" X3 A) w0 X, z6 T
当然，最后我们还需要介绍一个额外的概念：排序的稳定性，那么什么是稳定性呢？如果说大小相同的两个元素在排序之前和排序之后的先后顺序不变，这个排序算法就是稳定的。我们刚刚介绍的冒泡排序只会在前者大于后者的情况下才会进行交换，所以说不会影响到原本相等的两个元素顺序，因此冒泡排序是稳定的排序算法。

/ G# _+ w# x+ W0 C- h插入排序
我们来介绍一种新的排序算法，插入排序，准确地说应该叫直接插入排序，它的核心思想就像我们玩斗地主一样。

* l8 ]$ b% F7 |4 p" ]" Z9 O* F; A

相信各位应该都玩过，每一轮游戏在开始之前，我们都要从牌堆去摸牌，那么摸到牌之后，在我们手中的牌顺序可能是乱的，这样肯定不行啊，牌都没理顺我们怎么知道哪些牌有多少呢？为了使得其有序，我们就会根据牌的顺序，将新摸过来的牌插入到对应的位置上，这样我们后面就不用再整理手里的牌了。
' _# F; {& x  k2 ?2 P: O$ _$ ^
" |6 C* i2 i. C' K  y而插入排序实际上也是一样的原理，我们默认前面的牌都是已经排好序的（一开始就只有第一张牌是有序状态），剩余的部分我们会挨着遍历，然后将其插到前面对应的位置上去，动画演示地址：https://visualgo.net/zh/sorting

设数组长度为N，详细过程为：

共进行N轮排序。
: W/ ^; U; B% o6 e+ U. W$ x每轮排序会从后面依次选择一个元素，与前面已经处于有序的元素，从后往前进行比较，直到遇到一个不大于当前元素的的元素，将当前元素插入到此元素的前面。
4 m& {% I9 p& l% h9 q% Z. u' q( G7 \插入元素后，后续元素则全部后移一位。
当后面的所有元素全部遍历完成，全部插入到对应的位置之后，排序完成。
# t3 s4 O- S1 [. b( G比如下面的数组：

+ Q8 M8 q4 f- R
* H2 n7 k: r9 @: _) L# {
+ o) O* T9 O( }0 s9 n此时我们默认第一个元素已经是处于有序状态，我们从第二个元素开始看：


; [" W1 `' F! F; L; L
3 A4 P0 [! R1 o+ [' B, e/ d  R将其取出，从后往前，与前面的有序序列依次进行比较，首先比较的是4，发现比4小，继续向前，发现已经到头了，所以说直接放到最前面即可，注意在放到最前面之前，先将后续元素后移，腾出空间：
1 ]; v5 x0 F/ x* p$ N( v( _( ?8 U
7 a7 O9 Z% e, N  T
* F0 |. k7 \* _3 G4 ^& z& q
接着插入即可：


1 m# ^2 E9 L4 c
目前前面两个元素都是有序的状态了，我们继续来看第三个元素：
" P3 o! n& ^, s: l1 @+ g3 ?
. d7 q1 [! g+ e2 h! c5 C& e

依然是从后往前看，我们发现上来就遇到了7小的4，所以说直接放到这个位置：
+ |2 u- m7 ~; c& _- `# e+ n9 d4 x# ]5 N
9 @$ D* w) J5 @
) t* L# V: M- {4 a
' B- c) P- ?  h6 R* @( ]$ W, ]现在前面三个元素都是有序状态了，同样的，我们继续来看第四个元素：
& \6 o! e1 F4 b7 N( e0 N4 E
" t, \  O3 f1 c7 L* m
3 G' N: n7 i0 r; t9 n; g7 k, o
依次向前比较，发现到头了都没找到比1还小的元素，所以说将前面三个元素全部后移：



1 X" Q% @# S( |' |将1插入到对应的位置上去：
* c6 N) O+ L9 a) Q, E) Q/ v* J% G
. P/ L, a2 Y3 D8 X
1 Z! E$ G0 a% f6 _
现在前四个元素都是有序的状态了，我们只需要按照同样的方式完成后续元素的遍历，最后得到的就是有序的数组了，我们来尝试编写一下代码：

void insertSort(int arr[], int size){
    for (int i = 1; i < size; ++i) {   //从第二个元素开始看
        int j = i, tmp = arr;   //j直接变成i，因为前面的都是有序的了，tmp相当于是抽出来的牌暂存一下
4 a& K0 |) }9 }' m- x        while (j > 0 && arr[j - 1] > tmp) {   //只要j>0并且前一个还大于当前待插入元素，就一直往前找
0 R8 O( a( v; q! B9 k# N9 d( j            arr[j] = arr[j - 1];   //找的过程中需要不断进行后移操作，把位置腾出来
            j--;
        }
0 E% `  n; h# g/ O+ L        arr[j] = tmp;  //j最后在哪个位置，就是是哪个位置插入
    }
5 M5 Z" O: j: J. R& L, _/ R* g}
1
2
3
! l) M+ ?+ O! s( x: c4
5 p6 G! R: {6 S/ r6 ?( }/ K5
6
7
9 v+ d) X! f* b4 `+ W$ t8
9
10
当然，这个代码也是可以改进的，因为我们在寻找插入位置上逐个比较，花费了太多的时间，因为前面一部分元素已经是有序状态了，我们可以考虑使用二分搜索算法来查找对应的插入位置，这样就可以节省查找插入点的时间了：
* m2 H! i0 A: p6 R, B+ m2 }
int binarySearch(int arr[], int left, int right, int target){
9 z, m; D: V) F& g9 v& k    int mid;
    while (left <= right) {
        mid = (left + right) / 2;
) D4 X. d# C3 F) h' u4 r        if(target == arr[mid]) return mid + 1;   //如果插入元素跟中间元素相等，直接返回后一位
* X- ^0 z" c5 u3 Z" H        else if (target < arr[mid])  //如果大于待插入元素，说明插入位置肯定在左边
            right = mid - 1;   //范围划到左边
6 x. Y2 U0 j4 {2 R        else   
            left = mid + 1;   //范围划到右边
, B$ x# d; \! [; ?- Z/ r8 a7 V    }
9 o" u$ L: y( }, m    return left;   //不断划分范围，left也就是待插入位置了
% t! f; U8 t/ @) y2 Y}

+ e  x, }' h0 W" U6 t9 W- ?void insertSort(int arr[], int size){
3 s; l# y# E  r, o( G    for (int i = 1; i < size; ++i) {
        int tmp = arr;
        int j = binarySearch(arr, 0, i - 1, tmp);   //由二分搜索来确定插入位置
        for (int k = i; k > j; k--) arr[k] = arr[k - 1];   //依然是将后面的元素后移
        arr[j] = tmp;
    }
' m) Z, k' u" W, L- N}
1
6 V; K, G  U) B  `, n2
3
% T4 S+ K0 e& v& x. B4 g4
- }* n, I, o" \, n5
: l  o+ O' \' B6 _% F6
7
8
+ ]  W, D3 C/ ^9
# d2 l! N( _, M8 p/ v10
11
12
, c% V+ ?( _. J# b: Q; @* s6 L13
14
  |/ V5 C& b1 `1 C15
16
7 s" l' G* }/ G# O( E17
18
19
7 p+ B# _1 B% I' t$ Y20
21
4 P) T( X  }; W# {8 O* r: i我们最后还是来讨论一下，插入排序算法的稳定性。那么没有经过优化的插入排序，实际上是不断向前寻找到一个不大于待插入元素的元素，所以说遇到相等的元素时只会插入到其后面，并没有更改相同元素原本的顺序，所以说插入排序也是稳定的排序算法（不过后面使用了二分搜索优化之后就不稳定了，比如有序数组中连续两个相等的元素，现在又来了一个相等的元素，此时中间的正好找到的是排在最前面的相等元素，返回其后一个位置，新插入的元素会将原本排在第二个的相等元素挤到后面去了）
! _" ]( k4 R( K/ \" @& Y
- x1 d, J6 Q8 d: A" T0 Q- E* f4 `选择排序
1 C% J% V$ c8 X$ ]6 t我们来看看最后一种选择排序（准确的说应该是直接选择排序），这种排序也比较好理解，我们每次都去后面找一个最小的放到前面即可，算法演示网站：https://visualgo.net/zh/sorting
8 Q& a: ?. l4 U0 E8 p
/ O/ w# n& f- A设数组长度为N，详细过程为：
8 x5 B' J3 j$ d
共进行N轮排序。
每轮排序会从后面的所有元素中寻找一个最小的元素出来，然后与已经排序好的下一个位置进行交换。
进行N轮交换之后，得到有序数组。
& `$ A2 C, _7 M- |比如下面的数组：


" l. {: h% U6 X# Y- S2 `
# h& o5 i" l/ t* q9 s& B7 a第一次排序需要从整个数组中寻找一个最小的元素，并将其与第一个元素进行交换：


1 h# O1 b0 d9 x6 W
交换之后，第一个元素已经是有序状态了，我们继续从剩下的元素中寻找一个最小的：
0 ?% G% R( O5 Z- a9 z

8 m. I# o9 H: k0 p( r
  A* E9 d3 H+ E7 c$ b2 q此时2正好在第二个位置，假装交换一下，这样前面两个元素都已经是有序的状态了，我们接着来看剩余的：
5 s( a0 U& Q7 P) a. O+ P


& U! p: j( `3 z/ j此时发现3是最小的，所以说直接将其交换到第三个元素位置上：


. ]' ~: I) Z) c: N1 x
这样，前三个元素都是有序的了，通过不断这样交换，最后我们得到的数组就是一个有序的了，我们来尝试编写一下代码：

, O# Y8 @0 @* R2 S: Uvoid selectSort(int arr[], int size){
! c8 H% ?; n6 }6 |2 s( \5 p    for (int i = 0; i < size - 1; ++i) {   //因为最后一个元素一定是在对应位置上的，所以只需要进行N - 1轮排序
        int min = i;   //记录一下当前最小的元素，默认是剩余元素中的第一个元素
        for (int j = i + 1; j < size; ++j)   //挨个遍历剩余的元素，如果遇到比当前记录的最小元素还小的元素，就更新
            if(arr[min] > arr[j])
% j! \6 P' Y6 x0 u9 W4 l! v2 J- w' T# a                min = j;
        int tmp = arr;    //找出最小的元素之后，开始交换
        arr = arr[min];
2 F8 R- p7 S6 A) J1 L        arr[min] = tmp;
    }
}
1
2 {4 X. i% G0 X* _. w' b9 K2 F- J2
6 K  L! W1 N5 {  K2 {( H' J3
4
1 j- r' ~$ h. ]$ C5
( s) G3 p  [  ?1 O" b6
/ \# s8 _2 }* Y: \( `; T7
+ g6 g/ c: k/ A) O/ j( S8
9
) a! |3 G7 M1 n8 M- Z10
11
当然，对于选择排序，我们也可以进行优化，因为每次都需要选一个最小的出来，我们不妨再顺手选个最大的出来，小的往左边丢，大的往右边丢，这样就能够有双倍的效率完成了。
5 E3 U( t7 n! d( P5 @
$ F) I# }: m6 R1 Nvoid swap(int * a, int * b){
" u/ Z3 {5 ]) s* |7 d! Z8 G. Z    int tmp = *a;
, c1 t. \* l& |' X" {9 W    *a = *b;
    *b = tmp;
}

. @4 u# X9 n- T) K7 A7 R/ T: V3 Bvoid selectSort(int arr[], int size){
* B% P0 }7 A4 s; l( D  a5 w0 {5 d5 Y    int left = 0, right = size - 1;   //相当于左端和右端都是已经排好序的，中间是待排序的，所以说范围不断缩小
    while (left < right) {
! C! I8 A$ F- s2 \        int min = left, max = right;
' G& n' e# z) [- r# @, Q2 B: D+ h        for (int i = left; i <= right; i++) {
            if (arr < arr[min]) min = i;   //同时找最小的和最大的
  }$ g+ j0 J" H5 A+ W            if (arr > arr[max]) max = i;
        }
        swap(&arr[max], &arr[right]);   //这里先把大的换到右边
        //注意大的换到右边之后，有可能被换出来的这个就是最小的，所以说需要判断一下
        //如果遍历完发现最小的就是当前右边排序的第一个元素
        //此时因为已经被换出来了，所以说需要将min改到换出来的那个位置
        if (min == right) min = max;
        swap(&arr[min], &arr[left]);   //接着把小的换到左边
        left++;    //这一轮完事之后，缩小范围
        right--;
1 `3 T) `4 Q7 P; G* ?$ O- F/ u    }
}
1
3 A! X2 }" D4 Z7 i2
3
4
- ?0 w0 r* t) F( h2 [5
/ b% d$ y% k+ E1 S) O5 ?, I% y6
- }  P: D& j' V* I5 X7
8
9
10
4 E  U) N" `# F8 F1 l11
8 h4 p3 a) M! U6 {12
13
+ U6 z( x( G# t! }  H14
, W5 o. H6 I: j9 @15
  h# o* F) b- s16
  e' k( J! ~9 Y. N$ r7 n17
18
19
20
21
22
$ R1 o0 b9 d0 `, ]23
& _# ^4 q$ n2 {9 l24
2 T0 h# h. {8 V最后我们来分析一下选择排序的稳定性，首先选择排序是每次选择最小的那一个，在向前插入时，会直接进行交换操作，比如原序列为 3,3,1，此时选择出1是最小的元素，与最前面的3进行交换，交换之后，原本排在第一个的3跑到最后去了，破坏了原有的顺序，所以说选择排序是不稳定的排序算法。
+ J- V; e6 l/ M) u, z) F
我们来总结一下上面所学的三种排序算法，假设需要排序的数组长度为n：
/ c* G6 {- E) i- A" d% H  N$ A. l! x
冒泡排序（优化版）：
最好情况时间复杂度：O ( n ) O(n)O(n)，如果本身就是有序的，那么我们只需要一次遍历，当标记检测到没有发生交换，直接就结束了，所以说一遍就搞定。
: [# T. r  ?0 x; ^3 @' h最坏情况时间复杂度：O ( n 2 ) O(n^2)O(n
2
9 w" ?. Z( H; ?0 q- H! R  |! |% m )，也就是硬生生把每一轮都吃满了，比如完全倒序的数组就会这样。
$ X2 K; @+ o6 z2 _0 R**空间复杂度：**因为只需要一个变量来暂存一下需要交换的变量，所以说空间复杂度为 O ( 1 ) O(1)O(1)
**稳定性：**稳定
6 Z" y+ S. [3 f) `8 m4 H插入排序：
# h+ t0 B" b& H" Y0 y5 r1 p  k4 k" n最好情况时间复杂度：O ( n ) O(n)O(n)，如果本身就是有序的，因为插入的位置也是同样的位置，当数组本身就是有序的情况下时，每一轮我们不需要变动任何其他元素。
  Y, e( |. i6 h' m, U, c# o最坏情况时间复杂度：O ( n 2 ) O(n^2)O(n
/ v# ^) @# {' Z( T4 ]1 u% ?2
7 N1 Y4 s! s  l7 Q )，比如完全倒序的数组就会这样，每一轮都得完完整整找到最前面插入。
# b7 x; E3 E" f空间复杂度：同样只需一个变量来存一下抽出来的元素，所以说空间复杂度为 O ( 1 ) O(1)O(1)
**稳定性：**稳定
, ^+ X5 |7 e- c+ T. S$ X* }1 {选择排序：
* u6 R) t+ T: _1 ?$ Q最好情况时间复杂度：O ( n 2 ) O(n^2)O(n
2
* `) y9 t  a5 Z; r$ ~' w6 E )，即使数组本身就是有序的，每一轮还是得将剩余部分挨个找完之后才能确定最小的元素，所以说依然需要平方阶。
最坏情况时间复杂度：O ( n 2 ) O(n^2)O(n
2 Y5 s+ r3 W( }" D2
+ M& |0 |4 c; c4 [ )，不用多说了吧。
3 r! I2 [4 \. n2 m空间复杂度：每一轮只需要记录最小的元素位置即可，所以说空间复杂度为 O ( 1 ) O(1)O(1)
**稳定性：**不稳定
表格如下，建议记住：

排序算法        最好情况        最坏情况        空间复杂度        稳定性
冒泡排序        O ( n ) O(n)O(n)        O ( n 2 ) O(n^2)O(n
7 C* W. |: H$ |! x0 l) h2
" C$ I8 g9 s- |0 g. A )        O ( 1 ) O(1)O(1)        稳定
插入排序        O ( n ) O(n)O(n)        O ( n 2 ) O(n^2)O(n
- V3 {4 ?- x6 P: d2
6 C( H/ c+ N5 @" c3 V, f& k )        O ( 1 ) O(1)O(1)        稳定
; m, ?" L) ?6 V' `6 i7 k选择排序        O ( n 2 ) O(n^2)O(n
2
; d% l) P2 u' C )        O ( n 2 ) O(n^2)O(n
2
# B. \' t3 N- p$ `4 x; I5 \" w )        O ( 1 ) O(1)O(1)        不稳定
$ e9 w& B' @; ~进阶排序
) \& j/ [1 |  `1 V. W前面我们介绍了三种基础排序算法，它们的平均情况时间复杂度都到达了 O ( n 2 ) O(n^2)O(n
! j" o. ?" }1 _9 a! X  v% s9 n2
)，那么能否找到更快的排序算法呢？这一部分，我们将继续介绍前面三种排序算法的进阶版本。
8 m3 a. b5 D. n
快速排序
在C语言程序设计篇，我们也介绍过快速排序，快速排序是冒泡排序的进阶版本，在冒泡排序中，进行元素的比较和交换是在相邻元素之间进行的，元素每次交换只能移动一个位置，所以比较次数和移动次数较多，效率相对较低。而在快速排序中，元素的比较和交换是从两端向中间进行的，较大的元素一轮就能够交换到后面的位置，而较小的元素一轮就能交换到前面的位置，元素每次移动的距离较远，所以比较次数和移动次数较少，就像它的名字一样，速度更快。

( z* F% c. @0 }& D6 i实际上快速排序每一轮的目的就是将大的丢到基准右边去，小的丢到基准左边去。
/ t% u/ s3 \+ {2 w( u6 E; S
设数组长度为N，详细过程为：
. @! m( [% u$ N% ^5 K/ _0 Z6 P
在一开始，排序范围是整个数组
! {1 l5 J( Z& w5 y0 o/ ~排序之前，我们选择整个排序范围内的第一个元素作为基准，对排序范围内的元素进行快速排序
先从最右边向左看，依次将每一个元素与基准元素进行比较，如果发现比基准元素小，那么就与左边遍历位置上的元素（一开始是基准元素的位置）进行交换，此时保留右边当前遍历的位置。
交换后，转为从左往右开始遍历元素，如果发现比基准元素大，那么就与之前保留的右边遍历的位置上的元素进行交换，同样保留左边当前的位置，循环执行上一个步骤。
( ^+ _% N! Q8 {9 n( N! u* A, G当左右遍历撞到一起时，本轮快速排序完成，最后在最中间的位置就是基准元素的位置了。
, Z4 u! ]6 _$ W: u以基准位置为中心，划分左右两边，以同样的方式执行快速排序。
比如下面的数组：

# |1 @, ?% B3 F# p# @
8 f' f) d1 `1 J# ^8 K) O1 o3 ]
, y5 ~  |6 f/ z+ A% b9 m首先我们选择第一个元素4作为基准元素，一开始左右指针位于两端：


: \( V. y& c- U. \
' K5 V# v3 r- z: Y: ]) l此时从右往左开始看，直到遇到一个比4小的元素，首先是6，肯定不是，将指针往后移动：

; c/ O, G6 J# h2 p5 G

4 [$ D; M4 M0 D. R- F8 A6 J6 ~此时继续让3和4进行比较，发现比4小，那么此时直接将3交换（其实直接覆盖过去就行了）到左边指针所指向的元素位置：
5 b9 T6 U2 u6 M7 _
' N% _$ Q. F9 h2 X# z/ G

% Y% g5 _( k4 j+ G7 l1 c; p5 w此时我们转为从左往右看，如果遇到比4大的元素，就交换到右边指针处，3肯定不是了，因为刚刚才缓过来，接着就是2：
. E; j5 H  k% X4 b6 g

8 `. r0 ~6 W' X# d% T; K" N1 C
2也没有4大，所以说继续往后看，此时7比4要大，那么继续交换：

# L3 f$ Z* S+ b  ]8 r( O

5 _4 `% ^1 r# E' k接着，又开始从右往左看：



此时5是比4要大的，继续向前，发现1比4要小，所以说继续交换：

7 u# @1 B7 e- p1 t9 j6 a
! i  l+ w+ Y/ Y  z9 M5 I
" D. d' G( J/ E& w接着又转为从左往右看，此时两个指针撞到一起了，排序结束，最后两个指针所指向的位置就是给基准元素的位置了：
; |6 ~0 u, ]4 q& q; H$ O7 T& L8 d3 B
5 l# ~9 E! K. U5 D
5 l) l: D. |. f
; B# x4 g9 ?% n0 R6 [1 t" q本轮快速排序结束后，左边不一定都是有序的，但是一定比基准元素要小，右边一定比基准元素大。接着我们以基准为中心，分成两个部分再次进行快速排序：



这样，我们最后就可以使得整个数组有序了，当然快速排序还有其他的说法，有些是左右都找到了再交换，我们这里的是只要找到就丢过去。既然现在思路已经清楚了，我们就来尝试实现一下快速排序吧：

# O' V' h& r( Q" U. Z; Uvoid quickSort(int arr[], int start, int end){
8 f' R* |. e8 {- k, r    if(start >= end) return;    //范围不可能无限制的划分下去，要是范围划得都没了，肯定要结束了
* U0 F6 ^1 B, o% q& N- r    int left = start, right = end, pivot = arr[left];   //这里我们定义两个指向左右两个端点的指针，以及取出基准
    while (left < right) {     //只要两个指针没相遇，就一直循环进行下面的操作
        while (left < right && arr[right] >= pivot) right--;   //从右向左看，直到遇到比基准小的
        arr[left] = arr[right];    //遇到比基准小的，就丢到左边去
% x. L' o' j' V- ?, A        while (left < right && arr[left] <= pivot) left++;   //从左往右看，直到遇到比基准大的
/ t* T' u' M( w  N3 I( c2 z$ r        arr[right] = arr[left];    //遇到比基准大的，就丢到右边去
2 u  M' [: h3 J( \/ ?    }
9 G' ~' g9 P* C' H3 e* |    arr[left] = pivot;    //最后相遇的位置就是基准存放的位置了
    quickSort(arr, start, left - 1);   //不包含基准，划分左右两边，再次进行快速排序
    quickSort(arr, left + 1, end);
}
, D! N6 o# l: R# J/ L1
! F4 @  [% h) A4 h1 J8 l  }2
5 _4 i- m) M! p- v' c3
4
9 M$ N  k( }5 x. f# B5 P, t5
* E" Q4 z! p+ Y3 }# y6
7
8
5 S3 h; {8 H+ R5 b! h9
8 o  k! j* q4 A6 |3 {8 f) j10
' r* C1 E) t3 j: s5 h1 b11
12
13
这样，我们就实现了快速排序。我们还是来分析一下快速排序的稳定性，快速排序是只要遇到比基准小或者大的元素就直接交换，比如原数组就是：2,2,1，此时第一个元素作为基准，首先右边1会被丢过来，变成：1,2,1，然后从左往右，因为只有遇到比基准2更大的元素才会换，所以说最后基准会被放到最后一个位置：1,2,2，此时原本应该在前面的2就跑到后面去了，所以说快速排序算法，是一种不稳定的排序算法。
  g* R, Z8 a/ b9 A1 d) m6 f
; _+ Z* H4 t7 H* V# j' X双轴快速排序（选学）

这里需要额外补充个快速排序的升级版，双轴快速排序，Java语言中的数组工具类则是采用的此排序方式对大数组进行排序的。我们来看看它相比快速排序，又做了哪些改进。首先普通的快速排序算法在遇到极端情况时可能会这样：
' F; E' \! r4 i7 T0 h- g
! Z0 n9 v0 s  A$ t) L

6 b6 U- Q( D4 O6 Y! `# i. o1 m整个数组正好是倒序的，那么相当于上来就要把整个数组找完，然后把8放到最后一个位置，此时第一轮结束：

' x$ V3 m) O) E! D5 R
& S6 k5 q% z9 T: \- ~
由于8直接跑到最右边了，那么此时没有右半部分，只有做半部分，此时左半部分继续进行快速排序：
! V3 h2 K/ v/ U9 [1 X


* w3 S1 P7 {& R% V5 b. g此时1又是最小的一个元素，导致最后遍历完了，1都还是在那个位置，此时没有左半部分，只有右半部分：

( y. z1 l  v* j( ~( ^2 d. z
: j3 V9 C2 ~# W$ ]7 t: y
, y$ ]: p* T! e. G% ^此时基准是7，又是最大的，真是太倒霉了，排完之后7跑到最左边，还是没有右半部分：

9 D% }/ P- }* H! H* q1 r4 Q

4 H5 B4 m0 t* o- d0 `5 {& W) o我们发现，在这种极端情况下，每一轮需要完整遍历整个范围，并且每一轮都会有一个最大或是最小的元素被推向两边，这不就是冒泡排序吗？所以说，在极端情况下，快速排序会退化为冒泡排序，因此有些快速排序会随机选取基准元素。为了解决这种在极端情况下出现的问题，我们可以再添加一个基准元素，这样即使出现极端情况，除非两边都是最小元素或是最大元素，否则至少一个基准能正常进行分段，出现极端情况的概率也会减小很多：
1 a3 P" d! ^: D4 t8 n! W# x2 P
/ o8 h. V! Q9 I/ F

此时第一个元素和最后一个元素都作为基准元素，将整个返回划分为三段，假设基准1小于基准2，那么第一段存放的元素全部要小于基准1，第二段存放的元素全部要不小于基准1同时不大于基准2，第三段存放的元素全部要大于基准2：
& Q- S2 p+ i  [+ V" @9 b+ B- ]3 P0 k


因此，在划分为三段之后，每轮双轴快排结束后需要对这三段分别继续进行双轴快速排序，最后就可以使得整个数组有序了，当然这种排序算法更适用于哪些量比较大的数组，如果量比较小的话，考虑到双轴快排要执行这么多操作，其实还不如插入排序来的快。
# l: @: h6 W7 h$ u+ o
我们来模拟一下双轴快速排序是如何进行的:
; q( Q) z6 v; y, u
9 i9 y. w  [4 f
3 L, U+ u3 M  f4 f3 z+ l
首先取出首元素和尾元素作为两个基准，然后我们需要对其进行比较，如果基准1大于基准2，那么需要先交换两个基准，只不过这里因为4小于6，所以说不需要进行交换。
+ w( C0 h$ s5 a4 k
+ L9 H' @+ j- W) m7 U4 W& q此时我们需要创建三个指针：
9 ?( X' e3 ^" s

0 P) d* H9 K2 y9 s  [( D1 W
因为有三个区域，其中蓝色指针位置及其左边的区域都是小于基准1的，橙色指针左边到蓝色指针之间的区域都是不小于基准1且不大于基准2的，绿色指针位置及其右边的区域都是大于基准2的，橙色指针和绿色指针之间的区域，都是待排序区域。
( t2 A# E" D0 G* v
首先我们从橙色指针所指元素开始进行判断，分三种情况：

如果小于基准1，那么需要先将蓝色指针向后移，把元素交换换到蓝色指针那边去，然后橙色指针也向后移动。
  s8 p* ^2 G, t. _/ [7 ~# |9 W, z如果不小于基准1且不大于基准2，那么不需要做什么，直接把橙色指针向前移动即可，因为本身就是这个范围。
如果大于基准2，那么需要丢到右边去，先将右边指针左移，不断向前找到一个不比基准2大的，这样才能顺利地交换过去。
首先我们来看看，此时橙色指针指向的是2，那么2是小于基准1的，我们需要先将蓝色指针后移，然后交换橙色和蓝色指针上的元素，只不过这里由于是同一个，所以说不变，此时两个指针都后移了一位：
- ^& v) j; P' b4 t# R; D" F7 D1 H

# }! V* v- q; ~
$ d/ R* ]4 S# ~% K同样的，我们继续来看橙色指针所指元素，此时为7，大于基准2，那么此时需要在右边找到一个不大于基准2的元素：


0 J4 c' O1 E( @& f
0 X* k, C( s5 N# o. I, V* i绿色指针从右开始向左找，此时找到3，直接交换橙色指针和蓝色指针元素：
4 O& o8 b$ ]# ~- s" o
/ Z7 [* A- w+ b: H: L

下一轮开始继续看橙色指针元素，此时发现是小于基准1的，所以说先向前移动蓝色指针，发现和橙色又在一起了，交换了跟没交换一样，此时两个指针都后移了一位：
- _; h/ i- c9 h1 o! E' w3 }0 N' V


# m$ `/ g2 u- r+ {. x+ j, \新的一轮继续来看橙色指针所指元素，此时我们发现1也是小于基准1的，先移动蓝色指针，再交换，在移动橙色指针，跟上面一样，交换个寂寞：


7 W8 Y- o, N# G1 O
此时橙色指针指向8，大于基准2，那么同样需要在右边继续找一个不大于基准2的进行交换：



! p! r8 _8 C. E1 a6 G此时找到5，满足条件，交换即可：


0 e6 g, s& @* J7 t6 d
我们继续来看橙色指针，发现此时橙色指针元素不小于基准1且不大于基准2，那么根据前面的规则，只需要向前移动橙色指针即可：
; d( N" m8 D3 J& y, B
! v, H. U$ A* r2 @3 `
6 M( b- [- ?: o2 D6 w$ s
此时橙色指针和绿色指针撞一起了，没有剩余待排序元素了，最后我们将两个位于两端点基准元素与对应的指针进行交换，基准1与蓝色指针交换，基准2与绿色指针进行交换：
+ ^5 S# Q' s  @) l) R
3 y4 q. L6 p7 z# q3 U. \: u
6 s  M% u4 O0 N& B3 e# T8 ~
! H) I/ P* ~) d' G4 {' E此时分出来的三个区域，正好满足条件，当然这里运气好，直接整个数组就有序了，不过按照正常的路线，我们还得继续对这剩下的三个区域进行双轴快速排序，最后即可排序完成。

现在我们来尝试编写一下双轴快速排序的代码：

, E0 j; O4 A; s% ~void dualPivotQuickSort(int arr[], int start, int end) {
    if(start >= end) return;     //首先结束条件还是跟之前快速排序一样，因为不可能无限制地分下去，分到只剩一个或零个元素时该停止了
    if(arr[start] > arr[end])    //先把首尾两个基准进行比较，看看谁更大
7 _$ \. q+ g$ |3 m# V        swap(&arr[start], &arr[end]);    //把大的换到后面去
; V9 K4 j" t4 T- |; Q* {, a    int pivot1 = arr[start], pivot2 = arr[end];    //取出两个基准元素
+ O9 X  Q# k% L    int left = start, right = end, mid = left + 1;   //因为分了三块区域，此时需要三个指针来存放
6 S# q$ P/ H3 t- R    while (mid < right) {    //因为左边冲在最前面的是mid指针，所以说跟之前一样，只要小于right说明mid到right之间还有没排序的元素
; r( Y5 A1 p! ]7 v& c! }        if(arr[mid] < pivot1)     //如果mid所指向的元素小于基准1，说明需要放到最左边
& N2 C8 m: Y$ |$ N/ W, P1 v            swap(&arr[++left], &arr[mid++]);   //直接跟最左边交换，然后left和mid都向前移动
) N/ P8 X# {' r+ V3 H* U        else if (arr[mid] <= pivot2) {    //在如果不小于基准1但是小于基准2，说明在中间
$ ]  G; u" B+ l- P7 m            mid++;   //因为mid本身就是在中间的，所以说只需要向前缩小范围就行
4 V) W+ |/ m6 j0 @/ ~) s! {  D! O        } else {    //最后就是在右边的情况了
            while (arr[--right] > pivot2 && right > mid);  //此时我们需要找一个右边的位置来存放需要换过来的元素，注意先移动右边指针
            if(mid >= right) break;   //要是把剩余元素找完了都还没找到一个比基准2小的，那么就直接结束，本轮排序已经完成了
            swap(&arr[mid], &arr[right]);   //如果还有剩余元素，说明找到了，直接交换right指针和mid指针所指元素
        }
    }
2 V8 T, b4 c  k6 E3 z    swap(&arr[start], &arr[left]);    //最后基准1跟left交换位置，正好左边的全部比基准1小
) `0 J$ v2 |! S" ?    swap(&arr[end], &arr[right]);     //最后基准2跟right交换位置，正好右边的全部比基准2大
# ^' ]8 J6 }8 P- _1 y+ q    dualPivotQuickSort(arr, start, left - 1);    //继续对三个区域再次进行双轴快速排序
    dualPivotQuickSort(arr, left + 1, right - 1);
    dualPivotQuickSort(arr, right + 1, end);
}
1
$ N1 b) X; F- ?; u2
7 g! Z. e( n) N. C3
, r5 V+ a4 C4 J! K5 g4
5
6
* m! v' |# N+ s6 O7
4 v1 K2 d1 y/ J' a: i( e8
; [- \- [0 z' T9
) T0 x5 o; F1 k8 I10
3 h8 E7 C* K: i% b11
* U1 p, Z% M1 y* U" @12
9 C1 A5 @- d) M/ y9 ]: W6 A13
) ~1 c. P4 q/ X+ ^1 q* s4 x9 y$ r14
15
- Q" H2 {; F" I; R+ ~; @16
9 Q% u0 P4 I, `6 s, A  \- Q* M17
+ U' f: \( ~: Y4 x18
19
20
21
22
23
此部分仅作为选学，不强制要求。
4 [. j% U* M, B" b: s8 }) z
希尔排序
, `% ^+ p1 J1 [$ F9 ~6 i希尔排序是直接插入排序的进阶版本（希尔排序又叫缩小增量排序）插入排序虽然很好理解，但是在极端情况下会出现让所有已排序元素后移的情况（比如刚好要插入的是一个特别小的元素）为了解决这种问题，希尔排序对插入排序进行改进，它会对整个数组按照步长进行分组，优先比较距离较远的元素。
8 r1 ^9 I3 Y5 M' i+ d: w
7 i# W6 r7 Q1 x+ [& S9 ?* X1 r8 g9 X这个步长是由一个增量序列来定的，这个增量序列很关键，大量研究表明，当增量序列为 dlta[k] = 2^(t-k+1)-1（0<=k<=t<=(log2(n+1))）时，效率很好，只不过为了简单，我们一般使用 n 2 \frac {n} {2}
2
n
; o- O1 B( n0 `4 l+ X: A# t​
4 q7 Q4 S( S/ P  |+ H$ F 、n 4 \frac {n} {4}
: O+ }+ u" j( t2 U* o9 L" b4
n
​
- _% f0 F, a3 U/ _1 l% E 、n 8 \frac {n} {8}
8
n
​
、…、1 这样的增量序列。

8 Z+ y1 V  H% O$ z: n% I设数组长度为N，详细过程为：

首先求出最初的步长，n/2即可。
1 }" y1 n6 O4 Q9 I" o我们将整个数组按照步长进行分组，也就是两两一组（如果n为奇数的话，第一组会有三个元素）
我们分别在这些分组内进行插入排序。
  v2 r, X. O# ^! D0 W3 V排序完成后，我们将步长/2，重新分组，重复上述步骤，直到步长为1时，插入排序最后一遍结束。
( F5 t" D3 p6 d- P4 G2 f这样的话，因为组内就已经调整好了一次顺序，小的元素尽可能排在前面，即使在最后一遍排序中出现遇到小元素要插入的情况，也不会有太多的元素需要后移。
! p2 L6 P7 X9 h0 O; \
我们以下面的数组为例：
! O+ }5 J/ c: R
! A) ]+ F6 _9 N; ~3 w1 i1 B5 F( Z3 l
$ q7 W$ X5 ^5 B/ h% I
% g( J, s9 ~* D首先数组长度为8，直接整除2，得到34，那么步长就是4了，我们按照4的步长进行分组：



1 b! D: L% c, c+ X7 R! _其中，4、8为第一组，2、5 为第二组，7、3为第三组，1、6为第四组，我们分别在这四组内进行插入排序，组内排序之后的结果为：
1 s" w' S9 x  b! r

3 A! o6 u. Q6 F% d5 {. E: A
* @7 |+ n% F" W- d: t& d可以看到目前小的元素尽可能地在往前面走，虽然还不是有序的，接着我们缩小步长，4/2=2，此时按照这个步长划分：

1 V$ h3 R- I# ?3 ~$ A
- p- x7 L1 @+ ]6 ]* B
此时4、3、8、7为一组，2、1、5、6为一组，我们继续在这两个组内进行排序，得到：
* W# k% n2 K  f* L) R

5 p3 `6 O( d$ P# o$ p
7 J  q3 r: H% e2 g8 W. `6 G% _" u最后我们继续将步长/2，得到2/2=1，此时步长变为1，也就相当于整个数组为一组，再次进行一次插入排序，此时我们会发现，小的元素都靠到左边来了，此时再进行插入排序会非常轻松。
9 M0 t' D0 g. Q: h" v) X/ |
我们现在就来尝试编写一下代码：
( [1 ~/ Z# b4 V. T( N7 T
void shellSort(int arr[], int size){
    int delta = size / 2;
" r8 f# |9 z! o! H! h    while (delta >= 1) {
! f( G9 G) o9 d5 b: }6 o        //这里依然是使用之前的插入排序，不过此时需要考虑分组了
: U; g" @% D6 f3 ]0 W        for (int i = delta; i < size; ++i) {   //我们需要从delta开始，因为前delta个组的第一个元素默认是有序状态
4 g5 x& E! K2 ?$ R            int j = i, tmp = arr;   //这里依然是把待插入的先抽出来
9 Y1 N; P1 d, t; C5 x% M, M7 K% ^            while (j >= delta && arr[j - delta] > tmp) {   
- G* b2 d: c3 w* T# k/ y                      //注意这里比较需要按步长往回走，所以说是j - delta，此时j必须大于等于delta才可以，如果j - delta小于0说明前面没有元素了
# I" `( ]/ o) x$ Z. _1 [$ k' |, ?                arr[j] = arr[j - delta];
                j -= delta;
7 F' N2 z  y* R            }
' [0 ]) ~' |) J( J; X! U            arr[j] = tmp;
% G5 M5 Q0 b/ N* I$ M        }
        delta /= 2;    //分组插排完事之后，重新计算步长
    }
7 \& q! b' X" G2 K# v, w}
% s; |, j, t% A; T' t$ v" V6 K1 ?1
- r6 J8 I2 U3 p) C% ?2
$ v1 U1 R5 N+ R! ~- p3
( [5 e) v3 ?: B+ ~- J$ @4
5
+ g; X) v# g& N9 r  A7 y6
7
7 E$ o3 j0 W& g! Q6 C" C8
, \8 H' X: L- p7 r- W  r0 _9
9 u5 W+ F( S0 G" [! R* A10
11
2 s+ D3 ~1 R. Q) h, v# Z! R12
. Y# v/ F" D" v: z7 N13
! Y8 e$ h1 }: |0 ^14
15
4 T2 g, d; u' U; x1 b7 x16
虽然这里用到了三层循环嵌套，但是实际上的时间复杂度可能比 O ( n 2 ) O(n^2)O(n
( r" d3 _5 L9 c8 |, E6 S0 c8 q2
) 还小，因为能够保证小的元素一定往左边靠，所以排序次数实际上并没有我们想象中的那么多，由于证明过程过于复杂，这里就不列出了。
4 C0 B1 \& q6 a( N
那么希尔排序是不是稳定的呢？因为现在是按步长进行分组，有可能会导致原本相邻的两个相同元素，后者在自己的组内被换到前面去了，所以说希尔排序是不稳定的排序算法。
. K5 Y- S2 O3 @* B) _  D6 l
) D2 l  H7 t& g8 R: q堆排序
我们来看最后一种，堆排序也是选择排序的一种，但是它能够比直接选择排序更快。还记得我们前面讲解的大顶堆和小顶堆吗？我们来回顾一下：

对于一棵完全二叉树，树中父亲结点都比孩子结点小的我们称为小根堆（小顶堆），树中父亲结点都比孩子结点大则是大根堆

得益于堆是一棵完全二叉树，我们可以很轻松地使用数组来进行表示：

+ z, B- d5 ?; G+ {) D

' |$ X' a# c8 E6 {9 G: l8 d" h我们通过构建一个堆，就可以将一个无序的数组依次输入，最后存放的序列是一个按顺序排放的序列，利用这种性质，我们可以很轻松地利用堆进行排序，我们先来写一个小顶堆：

" T+ {, v, d7 F/ M1 Wtypedef int E;
typedef struct MinHeap {
1 L( r. Z: y. O' T/ s' _# j* @5 E    E * arr;
; F  m0 e0 g& e" A9 l, U) M    int size;
    int capacity;
: T$ e) b6 ~+ D0 _8 \9 k% ]) s} * Heap;

/ t+ _' W* N( S" k$ c7 u_Bool initHeap(Heap heap){
; q' c; U, l" {! x1 h    heap->size = 0;
, a& \, |7 k$ v$ T8 R    heap->capacity = 10;
    heap->arr = malloc(sizeof (E) * heap->capacity);
, a% \5 d, W, H; U. R3 n    return heap->arr != NULL;
: Z; D, d, I0 [$ ^4 O$ Q}

_Bool insert(Heap heap, E element){
    if(heap->size == heap->capacity) return 0;
$ A! T& Q0 n' A5 C* M    int index = ++heap->size;
    while (index > 1 && element < heap->arr[index / 2]) {
) R3 d$ [. M. t4 L) l        heap->arr[index] = heap->arr[index / 2];
        index /= 2;
6 z$ Z. b, i- w' H0 D    }
0 r6 `0 r" {" _    heap->arr[index] = element;
    return 1;
3 T/ w8 l' d* b# Y! q+ h}
; \, C& w. I2 q- K: ?
* @' n' g/ J+ ~+ G( ]7 v0 Y  tE delete(Heap heap){
2 p5 z: }4 o2 i3 W    E max = heap->arr[1], e = heap->arr[heap->size--];
    int index = 1;
+ u0 S  }9 K% p) H/ m* g+ ^    while (index * 2 <= heap->size) {
; b4 H$ a: K8 K  D        int child = index * 2;
2 q- U# o+ O$ t3 S0 S        if(child < heap->size && heap->arr[child] > heap->arr[child + 1])
1 R# T2 l; A3 l4 I1 [* s, Y6 {9 f- ~            child += 1;
& q( A& T2 Y- d6 n4 i# M; e+ W        if(e <= heap->arr[child]) break;
        else heap->arr[index] = heap->arr[child];
        index = child;
    }
    heap->arr[index] = e;
    return max;
}
8 \) b; L7 V+ s1
8 |$ @  c- F* Z* _2
3
) J# S1 s, k8 x& A- Z: F) e; A4
4 i: t, ?- [1 ?: i6 Z0 R- L5
6
' @: x% H4 V+ H0 S, M0 ^7
2 f! e- N% R  H- T8
9
10
11
12
; h/ Y3 V- q, N" {13
14
15
16
17
, G: {# Z0 Z# U2 `& W( ?8 A18
19
; h+ x# R& R: h7 r- ?20
21
22
% I: h2 X! \" S0 O23
24
/ [- L& U! O; Q1 s1 f25
+ D/ Q' h, X  T& u; q2 `26
27
28
29
4 F6 H. N7 q) r$ O+ y* T( Z30
4 E$ p4 F0 @: A" P, C/ ~31
; ^" w  w$ T& h  E! a32
33
  r7 W% `' s# L8 v7 }5 }: N+ f34
. R2 M3 x7 A1 M6 F. c35
36
37
38
8 E# _% L5 R+ A39
接着我们只需要将这些元素挨个插入到堆中，然后再挨个拿出来，得到的就是一个有序的顺序了：
4 g+ G( G( B" p2 F9 @2 Y+ P2 r
int main(){
    int arr[] = {3, 5, 7, 2, 9, 0, 6, 1, 8, 4};
" i+ @5 e& w  }; n8 X- m
    struct MinHeap heap;    //先创建堆
. K" e0 Q8 v" o" v  m8 O5 }0 P    initHeap(&heap);
    for (int i = 0; i < 10; ++i)
: Z2 a8 a+ y% i! ?) _# A6 P        insert(&heap, arr);   //直接把乱序的数组元素挨个插入
    for (int i = 0; i < 10; ++i)
: J& T0 d8 n. @) |* c7 ]        arr = delete(&heap);    //然后再一个一个拿出来，就是按顺序的了

7 M, y$ w( Q2 K; q( a+ B& W9 a0 S3 P) x    for (int i = 0; i < 10; ++i)
) C; p' M: g0 \        printf("%d ", arr);
  s- D( O! ]6 Y) k# z' ]* T, m, B}
7 l% m  W* n, C2 d* e1
2
( o) ^0 s$ R# G) j( C7 t3
4
5
6
$ V, K) ]9 Z+ I' E) T4 `/ }7
8
9
10
11
: F* G; a- l* P4 h8 Q1 f! k8 @12
9 x( G; v8 Y/ N1 u( C13
% X8 n% s0 |/ k  w9 g( {最后得到的结果为：
' [! z) |8 v" b: o7 s


3 H. r4 E$ g  |3 v8 e$ _/ C虽然这样用起来比较简单，但是需要额外 O ( n ) O(n)O(n) 的空间来作为堆，所以我们可以对其进行进一步的优化，减少其空间上的占用。那么怎么进行优化呢，我们不妨换个思路，直接对给定的数组进行堆的构建。
; }) I9 d+ P9 r+ d, [. m9 t
6 Q, }. l: z7 d% h' a( j5 ]( }: A设数组长度为N，详细过程为：
9 c$ o* `/ I( i: E
首先将给定的数组调整为一个大顶堆
& y6 y. E7 q# e7 w进行N轮选择，每次都选择大顶堆顶端的元素从数组末尾开始向前存放（交换堆顶和堆的最后一个元素）
交换完成后，重新对堆的根结点进行调整，使其继续满足大顶堆的性质，然后重复上述操作。
当N轮结束后，得到的就是从小到大排列的数组了。
5 J. B, B4 v2 Z我们先将给定数组变成一棵完全二叉树，以下面数组为例：
! {4 j& ]* ^$ m$ M. [

: |# q  g+ x( R
1 A! x. U# ?! C: D$ ^1 z此时，这棵二叉树还并不是堆，我们的首要目标是将其变成一个大顶堆。那么怎么将这棵二叉树变成一个大顶堆呢？我们只需要从最后一个非叶子结点（从上往下的顺序）开始进行调整即可，比如此时1是最后一个非叶子结点，所以说就从1开始，我们需要进行比较，如果其孩子结点大于它，那么需要将最大的那个孩子交换上来，此时其孩子结点6大于1，所以说需要交换：
( \4 v! V* z2 F/ @- D8 A
( h" B- |# b6 V1 i
2 g3 j. c) v) l2 F
0 X  E4 p4 z3 _+ P% f接着我们来看倒数第二个非叶子结点，也就是7，那么此时两个孩子都是小于它的，所以说不需要做任何调整，我们接着来看倒数第三个非叶子结点2，此时2的两个孩子6、8都大于2，那么我们选择两个孩子里面一个最大的交换上去：


7 x' t2 d, \  }8 F# ]! g( K
最后就剩下根结点这一个非叶子结点了，此时我们4的左右孩子都大于4，那么依然需要进行调整：
7 m& j: U  E$ _" M' D0 W/ X/ ^5 c
" g. V0 Y6 l5 a2 c  S0 W[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-87a7s1F4-1662545089947)(/Users/nagocoler/Library/Application Support/typora-user-images/image-20220906221657599.png)]

在调整之后，还没有结束，因为此时4换下去之后依然不满足大顶堆的性质，此时4的左孩子大于4，我们还需要继续向下看：
( R; w6 \! K2 w  R/ A1 u. s  a


) }( t' f, X) x: i' }交换之后，此时整个二叉树就满足大顶堆的性质了，我们第一次初始调整也就完成了。

此时开始第二步，我们需要一个一个地将堆顶元素往后面进行交换，相当于每次都去取一个最大的出来，直到取完，首先交换堆顶元素和最后一个元素：

* P& A/ _! U# J2 P: w8 {

此时整个数组中最大的元素已经排到对应的位置上了，然后我们不再考虑最后一个元素，此时将前面的剩余元素继续看做一棵完全二叉树，对根结点重新进行一次堆化（只需要调整根结点即可，因为其他非叶子结点的没有变动），使得其继续满足大顶堆的性质：


. e8 q, {. R" R
, W, h) H8 G! W还没完，继续调整：
, W& h0 {. _4 {3 F2 a$ M# R: r" i- b
2 O$ V0 H4 K, @" z( W( k$ F

此时第一轮结束，接着第二轮，重复上述操作，首先依然是将堆顶元素丢到倒数第二个位置上，相当于将倒数第二大的元素放到对应的位置上去：

8 q9 |. @0 m3 F. u$ s
; r, n9 n. v& k  Y& w
/ u, u4 B6 l( B2 M/ x3 }% w此时已经有两个元素排好序了，同样的，我们继续将剩余元素看做一个完全二叉树，继续对根结点进行堆化操作，使得其继续满足大顶堆性质：



$ f/ ?7 r, x7 B" J8 l6 D' c第三轮同样的思路，将最大的交换到后面去：

" _) }* c3 R3 L% H3 C) D

通过N轮排序，最后每一个元素都可以排到对应的位置上了，根据上面的思路，我们来尝试编写一下代码：
+ D- q3 v* M- |/ G# c. |- x! E3 j
; w8 z5 Q, K* B+ R. e  C' N//这个函数就是对start顶点位置的子树进行堆化
void makeHeap(int* arr, int start, int end) {
    while (start * 2 + 1 <= end) {    //如果有子树，就一直往下，因为调整之后有可能子树又不满足性质了
6 o, Q" D$ X' C; Q: K        int child = start * 2 + 1;    //因为下标是从0开始，所以左孩子下标就是i * 2 + 1，右孩子下标就是i * 2 + 2
) N" h. `/ H1 r! R$ W7 S# }        if(child + 1 <= end && arr[child] < arr[child + 1])   //如果存在右孩子且右孩子比左孩子大
$ d# @) t( h. I" \            child++;    //那就直接看右孩子
        if(arr[child] > arr[start])   //如果上面选出来的孩子，比父结点大，那么就需要交换，大的换上去，小的换下来
" N' ]$ {2 u; c# c            swap(&arr[child], &arr[start]);
        start = child;   //继续按照同样的方式前往孩子结点进行调整
    }
6 m; A' V3 p0 K1 d$ l}

1 ?+ m/ B0 o& q* U' a* |void heapSort(int arr[], int size) {
    for(int i= size/2 - 1; i >= 0; i--)   //我们首选需要对所有非叶子结点进行一次堆化操作，需要从最后一个到第一个，这里size/2计算的位置刚好是最后一个非叶子结点
3 r: c  }( A6 k4 a7 k$ C        makeHeap(arr, i, size - 1);
    for (int i = size - 1; i > 0; i--) {   //接着我们需要一个一个把堆顶元素搬到后面，有序排列
3 k/ j) P; |. `6 P) C: G        swap(&arr, &arr[0]);    //搬运实际上就是直接跟倒数第i个元素交换，这样，每次都能从堆顶取一个最大的过来
) x" ^  N7 G- }1 R1 U        makeHeap(arr, 0, i - 1);   //每次搬运完成后，因为堆底元素被换到堆顶了，所以需要再次对根结点重新进行堆化
    }
9 C3 _: g; m% Z}
, A  W( H2 @: g( {1 y1
7 D6 r: H9 {# f8 n7 K' Q/ X2
* a7 z9 k- D3 N1 r9 }3
  P1 b/ S) A- _! a: h3 J4
% M6 n& f1 o2 C2 k, T  {5
  N) x2 L/ t4 L+ T9 v6
! g5 g3 f' N. w6 }! I% \0 n7
) N2 r$ m3 H: B) Q7 o  D8
% n  v/ e  I, a5 @7 v% q$ G! I) F9
. P1 G1 e) y. `5 F  w* L- B6 f10
11
5 Z5 q3 F+ u7 T7 C) J1 O! B12
3 Y7 I- [7 T& c13
14
8 v# r- Z9 O' r15
0 e1 {; D! Y% p1 M16
; `, Y8 z: g/ S* U17
18
19
' z3 j/ g' o5 s20
最后我们来分析一下堆排序的稳定性，实际上堆排序本身也是在进行选择，每次都会选择堆顶元素放到后面，只不过堆是一直在动态维护的。实际上从堆顶取出元素时，都会与下面的叶子进行交换，有可能会出现：

/ _7 k5 t- D: X4 g

所以说堆排序是不稳定的排序算法。

; }! l6 [7 |* J9 c6 `最后我们还是来总结一下上面的三种排序算法的相关性质：
5 V3 }: {  z* R* z* w+ o( P
( F- r; f- Z0 a1 d( M排序算法        最好情况        最坏情况        空间复杂度        稳定性
9 m2 C* v- x5 T$ }5 h快速排序        O ( n l o g n ) O(nlogn)O(nlogn)        O ( n 2 ) O(n^2)O(n
2
)        O ( l o g n ) O(logn)O(logn)        不稳定
希尔排序        O ( n 1.3 ) O(n^{1.3})O(n
1.3
)        O ( n 2 ) O(n^2)O(n
2
)        O ( 1 ) O(1)O(1)        不稳定
堆排序        O ( n l o g n ) O(nlogn)O(nlogn)        O ( n l o g n ) O(nlogn)O(nlogn)        O ( 1 ) O(1)O(1)        不稳定
/ A2 w" `5 U# T% j# ~0 `7 ]& U) U! Y# [其他排序方案
除了我们前面介绍的几种排序算法之外，还有一些其他类型的排序算法，我们都来认识一下吧。

归并排序
归并排序利用递归分治的思想，将原本的数组进行划分，然后首先对划分出来的小数组进行排序，然后最后在合并为一个有序的大数组，还是很好理解的：



我们以下面的数组为例：

, [  M4 A, `7 {
  Q: O6 T" f, E! ~$ y
在一开始我们先不急着进行排序，我们先一半一半地进行划分：



继续进行划分：

5 ^: v( x4 E3 }) U" G

* ^" S- A! [  s4 U' w( Z9 y* H; y) g8 M最后会变成这样的一个一个的元素：

  {; D; {) F; W8 o3 g5 k

. L, x* S" n& B5 [此时我们就可以开始归并排序了，注意这里的合并并不是简简单单地合并，我们需要按照从小到大的顺序，依次对每个元素进行合并，第一组树4和2，此时我们需要从这两个数组中先选择小的排到前面去:


  {: F3 X( Q) e! L! l0 j
排序完成后，我们继续向上合并：
; x9 f0 c  u" d# X
+ w: b( F: k4 C) l( N- P: c: h  h

最后我们再将这两个数组合并到原有的规模：

1 ^( N8 @5 h5 t1 P7 ]

$ T2 X( S1 X+ B- X2 d& Z最后就能得到一个有序的数组了。

1 L# v! y, f# a. j1 y4 e实际上这种排序算法效率也很高，只不过需要牺牲一个原数组大小的空间来对这些分解后的数据进行排序，代码如下：

4 M' i" }* T2 S9 R1 R3 {void merge(int arr[], int tmp[], int left, int leftEnd, int right, int rightEnd){
6 ?7 A7 ]& b; J9 _    int i = left, size = rightEnd - left + 1;   //这里需要保存一下当前范围长度，后面使用
% `  L1 C" t2 ~: r. f7 l" y2 P    while (left <= leftEnd && right <= rightEnd) {   //如果两边都还有，那么就看哪边小，下一个就存哪一边的
- _# E! A6 K- w5 A        if(arr[left] <= arr[right])   //如果左边的小，那么就将左边的存到下一个位置（这里i是从left开始的）
            tmp[i++] = arr[left++];   //操作完后记得对i和left都进行自增
- `, ~% X8 s1 R1 G# K( v5 Q        else
# c( Y( t, [- M# |. G9 R            tmp[i++] = arr[right++];
: d- R+ Z+ V4 `" t    }
, A' h7 v  {5 M8 Z    while (left <= leftEnd)    //如果右边看完了，只剩左边，直接把左边的存进去
        tmp[i++] = arr[left++];
3 K+ S$ H$ F" D( M5 w+ D    while (right <= rightEnd)   //同上
1 B8 }, L) x  R* I# X/ b        tmp[i++] = arr[right++];
1 ~, r3 Q0 Y8 ~; L% C    for (int j = 0; j < size; ++j, rightEnd--)   //全部存到暂存空间中之后，暂存空间中的内容都是有序的了，此时挨个搬回原数组中（注意只能搬运范围内的）
        arr[rightEnd] = tmp[rightEnd];
}

7 w6 v; O7 A8 |3 {0 }" B8 a% N' ]$ ?void mergeSort(int arr[], int tmp[], int start, int end){   //要进行归并排序需要提供数组和原数组大小的辅助空间
    if(start >= end) return;   //依然是使用递归，所以说如果范围太小，就不用看了
    int mid = (start + end) / 2;   //先找到中心位置，一会分两半
0 D9 N& Q, Y8 j# n+ }- s4 t    mergeSort(arr, tmp, start, mid);   //对左半和右半分别进行归并排序
    mergeSort(arr, tmp, mid + 1, end);
    merge(arr, tmp, start, mid, mid + 1, end);  
% @" q9 K* Y- o! T, c& O, x( ]          //上面完事之后，左边和右边都是有序状态了，此时再对整个范围进行一次归并排序即可
1 y6 B2 T4 x' T. Z. b6 E}
1
2
  s' g4 I; y6 }) a5 ~  d* X3
4
) H0 R$ W' Q, F. [- x& s# E5
6
5 g7 i2 V- t0 c2 o3 x- B: t7
2 Q4 V) w6 r7 _8
9
3 s- L  _) r# x/ b0 C! I10
0 l0 d3 z. ^* U1 W- ?6 A# o11
  l% p. v+ |6 g5 k9 W12
1 F% X0 q4 W* @2 G. L& s# x+ J13
4 L3 }) ~- Y- ^. I3 T' z. A14
15
16
1 P; b$ K+ N/ v% Q% s, T; ]$ o, D17
+ g% I1 E$ J% C+ H  J. U4 ^18
+ J$ {" n* }. I$ \& }# Z; z19
& O0 T3 W# W/ a20
21
2 P1 \. N6 |" J' [3 c22
23
, o$ q) V3 ^: U24
因为归并排序最后也是按照小的优先进行合并，如果遇到相等的，也是优先将前面的丢回原数组，所以说排在前面的还是排在前面，因此归并排序也是稳定的排序算法。
. x' p4 K+ q3 `# R
# R9 V8 K/ D! G) [8 K桶排序和基数排序
在开始讲解桶排序之前，我们先来看看计数排序，它要求是数组长度为N，且数组内的元素取值范围是0 - M-1 之间（M小于等于N）
) _$ t+ M& Z. l; ?" h& Y3 |
算法演示网站：https://visualgo.net/zh/sorting?slide=1
3 a3 C& l. n+ V/ m. s* g
比如下面的数组，所有的元素范围是 1-6之间：
0 k+ e& F. A8 U# O2 w* |) ?
* m3 d4 W% L" J3 I

2 W- p& K/ N% `' U) P我们先对其进行一次遍历，统计每个元素的出现次数，统计完成之后，我们就能够明确在排序之后哪个位置可以存放值为多少的元素了：
" G) P* F+ `4 @( z
4 f* ]$ t7 y8 o2 F+ `7 x& K4 }0 \- v' S

我们来分析一下，首先1只有一个，那么只会占用一个位置，2也只有一个，所以说也只会占用一个位置，以此类推：
& ~. f- t( j; t+ \6 S
! }2 D, B6 E" ~2 j9 r8 f
( M- T) o/ e- J1 W% H/ W$ b, d
7 }  Z/ _5 `: [所以说我们直接根据统计的结果，把这些值挨个填进去就行了，而且还是稳定的，按顺序，有几个填几个就可以了：
- D& S) P; u( s

7 N6 X& a4 I; `( X% Q% P. V
. S% d% p! `3 {- Y4 m; B是不是感觉很简单，而且只需要遍历一次进行统计就行了。

7 A% f( s# i! U1 |当然肯定是有缺点的：

当数组中最大最小值差距过大时，我们得申请更多的空间来进行计数，所以不适用于计数排序。
当数组中元素值不是离散的（也就是不是整数的情况下）就没办法统计了。
我们接着来看桶排序，它是计数排序的延伸，思路也比较简单，它同样要求是数组长度为N，且数组内的元素取值范围是0 - M-1 之间（M小于等于N），比如现在有1000个学生，现在需要对这些学生按照成绩进行排序，因为成绩的范围是0-100，所以说我们可以建立101个桶来分类存放。

比如下面的数组：
, P( g( b) F$ V  i

2 _  Z& L4 d6 F0 {8 Q! q
此数组中包含1-6的元素，所以说我们可以建立 6个桶来进行统计：

+ J/ T* n9 Y3 h
% O* R& d# ]$ T: r; K
4 N7 R' b/ W) T- m: U4 m5 t' D7 c2 J0 u这样，我们只需要遍历一次，就可以将所有的元素分类丢到这些桶中，最后我们只需要依次遍历这些桶，然后把里面的元素拿出来依次存放回去得到的就是有序的数组了：
. D  d% m# x1 O% h

( K3 n/ M  R# d" V/ ^5 [
只不过桶排序虽然也很快，但是同样具有与上面计数排序一样的限制，我们可以将每个桶接纳一定范围内的元素，来减小桶的数量，但是这样会导致额外的时间开销。
1 I  u  T1 C$ R
( ~, G4 `" `5 I3 f) x我们最后来看看基数排序，基数排序依然是一种依靠统计来进行的排序算法，但是它不会因为范围太大而导致无限制地申请辅助空间。它的思路是，分出10个基数出来（从0 - 9）我们依然是只需要遍历一次，我们根据每一个元素的个位上的数字，进行分类，因为现在有10个基数，也就是10个桶。个位完事之后再看十位、百位…

算法演示网站：https://visualgo.net/zh/sorting

! |' K6 A0 l. I" Q% y$ X
, |+ P) h# R+ t$ E& g
先按照个位数进行统计，然后排序，再按照十位进行统计，然后排序，最后得到的结果就是最终的结果了：



然后是十位数：



最后再次按顺序取出来：

0 s4 w; s7 ?+ l, q" L! R8 n$ c
- J4 p  G: s8 F# C- U$ R5 M: c成功得到有序数组。

最后我们来总结一下所有排序算法的相关性质：
* x* {* p0 {2 I, o0 ^
  E# V5 q6 P8 K; v排序算法        最好情况        最坏情况        空间复杂度        稳定性
冒泡排序        O ( n ) O(n)O(n)        O ( n 2 ) O(n^2)O(n
5 i1 h3 e5 T# N: {7 ]; [8 L2
)        O ( 1 ) O(1)O(1)        稳定
* {' X/ G% G) @+ `) ?插入排序        O ( n ) O(n)O(n)        O ( n 2 ) O(n^2)O(n
2
5 I# Y5 G8 V" s- g )        O ( 1 ) O(1)O(1)        稳定
选择排序        O ( n 2 ) O(n^2)O(n
2
+ B- a! R; y/ `: p )        O ( n 2 ) O(n^2)O(n
2
/ P' H# t) [1 C2 o4 W )        O ( 1 ) O(1)O(1)        不稳定
快速排序        O ( n l o g n ) O(nlogn)O(nlogn)        O ( n 2 ) O(n^2)O(n
2
. X+ k/ ~5 X1 T$ U3 c; N8 p )        O ( l o g n ) O(logn)O(logn)        不稳定
希尔排序        O ( n 1.3 ) O(n^{1.3})O(n
1.3
) X+ c$ t( q* y% O8 I )        O ( n 2 ) O(n^2)O(n
" ]3 m# F9 O5 y8 _6 b% h! c8 V- v2
)        O ( 1 ) O(1)O(1)        不稳定
堆排序        O ( n l o g n ) O(nlogn)O(nlogn)        O ( n l o g n ) O(nlogn)O(nlogn)        O ( 1 ) O(1)O(1)        不稳定
归并排序        O ( n l o g n ) O(nlogn)O(nlogn)        O ( n l o g n ) O(nlogn)O(nlogn)        O ( n ) O(n)O(n)        稳定
计数排序        O ( n + k ) O(n + k)O(n+k)        O ( n + k ) O(n + k)O(n+k)        O ( k ) O(k)O(k)        稳定
桶排序        O ( n + k ) O(n + k)O(n+k)        O ( n 2 ) O(n^2)O(n
2
)        O ( k + n ) O(k + n)O(k+n)        稳定
3 p4 g( M  ~! ~$ p基数排序        O ( n × k ) O(n \times k)O(n×k)        O ( n × k ) O(n \times k)O(n×k)        O ( k + n ) O(k+n)O(k+n)        稳定
3 Q% Q- L0 G' Z! D7 q( @猴子排序
猴子排序比较佛系，因为什么时候能排完，全看运气！
7 B. p3 [5 \0 I0 o
- U) Q- [/ @- b1 m无限猴子定理最早是由埃米尔·博雷尔在1909年出版的一本谈概率的书籍中提到的，此书中介绍了“打字的猴子”的概念。无限猴子定理是概率论中的柯尔莫哥洛夫的零一律的其中一个命题的例子。大概意思是，如果让一只猴子在打字机上随机地进行按键，如果一直不停的这样按下去，只要时间达到无穷时，这只猴子就几乎必然可以打出任何给定的文字，甚至是莎士比亚的全套著作也可以打出来。

假如现在有一个长度为N的数组：
2 K/ S: o, |; A: n
) A. m7 B: E# z/ P4 Z6 o

我们每次都随机从数组中挑一个元素，与随机的一个元素进行交换：
; f7 {5 o! B1 k% p
4 ~  Y6 g4 w; t6 m0 e" \) A

只要运气足够好，那么说不定几次就可以搞定，要是运气不好，说不定等到你孙子都结婚了都还没排好。

代码如下：

& n4 \. e. S/ j1 @- ~. B( W_Bool checkOrder(int arr[], int size){
    for (int i = 0; i < size - 1; ++i)
        if(arr > arr[i + 1]) return 0;
4 \$ K( `% [& ]. {. T. p; |    return 1;
}

int main(){
    int arr[] = {3,5, 7,2, 9, 0, 6,1, 8, 4}, size = 10;

+ v, T# z" z( o    int counter = 0;
    while (1) {
        int a = rand() % size, b = rand() % size;
+ K8 b% f2 p" ?4 T) ~- t. h" ^        swap(&arr[a], &arr);
        if(checkOrder(arr, size)) break;
* P0 Q' Y& [" W        counter++;
$ s* [0 J$ s& E- g% l" F    }
# b' v3 l1 B3 K. |5 {' K. O; V    printf("在第 %d 次排序完成！", counter);
% V2 P  P  n, x1 Y. M: |" _}
1
2
3 f2 y7 D0 t8 U& ~8 J" y3
4
5
6
5 n$ B) K2 l% R1 M3 K: \( ]7
+ c+ G, [, b$ Y2 o+ E$ Q8
9
7 w" e2 k- Z( v- ?) ^/ B3 W10
8 t& t- ]; c5 X' M7 b/ D# ~" z, \11
# x9 \) c* `) T1 W  Z12
& A% d8 E! F7 n; H13
; m; ?/ v) n3 H$ j14
15
16
, L3 h$ D- O3 r2 o! ^, f! W17
7 q$ r$ `# m1 B2 P% ~" E2 x18
可以看到在10个元素的情况下，这边第7485618次排序成功了：
) ]0 [/ Z/ B  j% F, K
: M" }$ d: _  W  [% o

但是不知道为什么每次排序出来的结果都是一样的，可能是随机数取得还不够随机吧。
( s% P" q4 j- R6 j; E8 l
排序算法        最好情况        最坏情况        空间复杂度        稳定性
猴子排序        O ( 1 ) O(1)O(1)        ∞        O ( 1 ) O(1)O(1)        不稳定
————————————————
& w# G6 [& h: L) z0 v5 P8 y版权声明：本文为CSDN博主「青空の霞光」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
) D  V2 w3 `( C+ L( f/ E, _原文链接：https://blog.csdn.net/qq_25928447/article/details/126751213
* y: ?3 {9 j( I$ y
; I, x/ K) k) C! W* u