数据结构：九种内部排序（动图+完整代码）

杨利霞

数据结构：九种内部排序（动图+完整代码）
5 @" l$ y% R/ Z
排序
- j/ X/ R, C# P0 N+ U' N3 |1. 插入排序
1.1 直接插入排序
1.2 折半插入排序
/ ^: |, }% |* v( S1.3 希尔排序
0 k8 a5 Z& ^+ V( `' q2. 交换排序
9 t  s' C2 {; r, n) J8 x8 |2.1 冒泡排序
2.2 快速排序
3 G& v7 x( u) d! Y3. 选择排序
) R1 v) k3 l+ j& L% G3.1 简单选择排序
3.2 堆排序
4. 归并排序和基数排序
4.1 归并排序
& V2 z, ?$ b: ]/ X) }( W/ h4.2 基数排序
# g/ O5 F7 x# }5 }  E! K7 C  H5. 内部排序算法比较及应用
7 \0 ^( \8 y+ R. I7 v# G6 X1 ^4 a& y+ y5.1 整体比较
* x8 ^7 G3 Y7 d( U1 c1 m% W5.2 时间、空间和稳定性
4 y+ N5 S, n) I参考资料

( B* `; f+ H. [) C+ {6 N2 K内部排序：是指在排序期间 元素全部放在内存中的排序。
! ]1 h9 @( o0 J' m5 o3 S内部排序算法的性能取决于算法的时间复杂度和空间复杂度。
5 a- f' ]1 b1 C/ [$ w' i8 i. Y8 L1. 插入排序
1.1 直接插入排序
图解

( L9 c% H6 \5 H$ g
/ b$ m/ ~# D0 A+ |基本思想
) @, G& F: E/ ]" v% j6 w' t
1. 查找a元素在第1 ~ i-1中的位置k
/ Y, U/ N' _) d2. 将k ~ i-1位置上的所有元素向后移动一个位置
3. 将a复制到a[k]

7 }) y9 Y* G% I
3 \: A$ z3 J% }# D4 d0 P
4 d; `# N& C6 z; r1 W6 h) `1 A; A代码

方法一：
$ ~/ ^( u& p; q, a: Y# X6 m
数组的下标从0开始，如上图。

# N, H2 a4 H5 ]7 d8 ^#include "stdio.h"
# t+ M: X$ K% ^
0 y% I5 R9 J4 n, ?7 gtypedef int ElemType;

0 Q8 z1 x( I" n# ~2 N- X/ Mvoid Insert(ElemType a[],int n){
    ElemType temp;
    int j;
5 B! n, i' Y& S$ b% O1 i# Q    for (int i = 1; i < n; ++i) {                                        //假设a[0]是有序的数组，从a[1]开始进行插入排序
4 a  l: m" ]; n+ t" @* _$ a        if (a<a[i-1]){
            temp=a;                                                               
            for (j = i-1; j >= 0&&a[j]>temp ; --j)        //将k ~ i-1位置上的所有元素向后移动一个位置
3 G% d: z1 |/ p0 B3 q+ V& s                a[j+1]=a[j];
0 |0 P8 a" n# v2 A            a[j+1]=temp;                                                       
        }
% m) I$ M/ N# c! D% v    }
}

int main(){
    int n;
    ElemType a[n];
    printf("一共有多少个数需要排序：");
4 E+ r+ d) X" n5 y. p8 n+ @    scanf("%d",&n);
    printf("请输入%d个数：",n);
& n4 D  \9 ]8 l" A2 G    for (int i = 0; i < n; ++i) {
- E( \' P: j- x1 m% [6 N4 o$ U( ~        scanf("%d",&a);
    }
    Insert(a,n);
    printf("排序后为：");
8 i' W$ b" Q2 y; V4 E    for (int i = 0; i < n; ++i) {
        printf("%d\t",a);
    }
}
* z3 l/ @. D  u6 V: V
1
2
7 P3 z& d' D- D7 x0 x1 t  u, ]  M3
; W9 A) V# h# Y9 @+ \  s4
5
% Y1 O& N  I/ S( O- |6 G6
7
4 E9 d6 z4 _1 Z7 n3 C( S8
9
10
11
12
/ P  U! ^2 K# Y/ {" c1 O" {6 @13
14
5 r! |3 |  q7 a" p' R" M2 T0 s15
16
1 X  A) v; H9 H0 K# j" N17
1 _# x: \$ S) N18
! x6 b5 h, ]( W- Y9 r19
5 f9 j& k7 @8 W& }. F% |20
21
22
4 F" q$ E9 B4 c  u23
24
* o; _" r1 R( c; j25
& g& U* h& Y1 y: A, _. p26
6 G0 j* M, ?8 c, O! A/ P  ?3 R27
( f$ y% M0 n" T( h( S; B* J28
29
30
. \, f4 _  s, k, s31
32
方法二：
) x; e5 ]; O8 ?5 J


#include "stdio.h"

/ ~6 L5 w8 L& A# g8 Ntypedef int ElemType;
1 S, p* Z6 p8 b& S9 {( a$ N" `
# _, ?. N( ?) N; Jvoid InsertSort(ElemType a[],int n){      
( t' X& ]" T0 }: K  j% ]    int i,j;
; B# i5 E; n3 X' l1 ~. S1 M    for (i = 2; i <=n; i++) {
0 l% `  j, x/ f. @1 E! `        if (a<a[i-1]){
            a[0]=a;
            for (j = i-1; a[0]<a[j]; --j)
/ o- ^4 I  K7 ]9 d                a[j+1]=a[j];
            a[j+1]=a[0];
        }
    }
$ |& e& z) M0 A( B  N8 M}
( j8 D$ C8 n( x, ?; z' M0 [) }int main(){
$ N; C1 a& s1 d) k0 o, b    int n;
% K/ b1 F& b  q2 ~2 p2 A+ E    ElemType a[n];
# D: I. B' D3 n    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
    printf("请输入%d个数：",n);
    for (int i = 1; i <= n; ++i) {
& `" L( m% z1 ^% p) A        scanf("%d",&a);
* t5 r8 A" |# Y- {! [5 O8 \    }
$ c; z) K! n& ~* m! |( k6 S5 x- i; |. B    InsertSort(a,n);
    printf("排序后为：");
' f5 [: v4 `6 S/ O9 t# G* c    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
- k3 {6 Z- x. O5 z$ W8 |# ~; ?- W1 ^    }
}

3 D; f% B. L& Y) h# G1
: ~! q2 ^4 g* i3 Y1 [' K2
3
4
3 Q+ R8 O* L& E, C5
. r! G. d' X0 q6 L6
! E* l* G. A+ A# [5 \$ ?& }, Z3 X$ _7
8
9
10
11
12
5 q8 X9 M/ ?8 N4 f8 ^8 Y* [13
* Z( i9 u1 C4 r9 X" ]14
15
2 ]7 S0 y5 `1 H6 ?! {16
17
18
19
20
0 {1 v$ o* y, R$ k/ z* X) a% {21
- a$ Q# M- E7 N% z22
1 I8 ~9 U+ r1 D9 t1 I/ i! G23
24
25
# |" d2 X  `& x4 B& g" H- e2 L+ W26
27
6 I1 ]* U7 R, M) ~28
1 s% [$ G0 j$ y9 Q, J29
/ H7 o/ |1 K; x30
% G$ U8 i# I# X算法性能
; g' ?" y" m0 e) l1 s
空间效率： 仅使用了常数个辅助单元，复杂度为：O ( 1 ) O(1)O(1)
& g' Q5 A' r6 [
5 y, l- C: ]6 l, u' [' q( U5 B时间效率： 平均时间复杂度：O ( n 2 ) O(n^2)O(n
2
)
5 e, g/ j1 Z! r
! e$ ?, Y. K2 ^2 p* U" ?; O- t) z4 K
3 ?% S( [0 M* R% s! C) v9 h稳定性： 由于每次插入元素时总是从后向前先比较在移动，所以不会出现相同元素相对位置发生变化的情况，即直接插入排序是一个稳定的排序方法。

  \9 w7 c9 e  j  \适用性： 适用于顺序存储和链式存储的线性表。为链式存储时，可以从前往后查找指定元素的位置。

+ Z" D& m( I- |9 D$ N# F, I4 ~1.2 折半插入排序
, B, [) \+ m0 c, p" T图解
; L9 T8 ~* n5 D( M- z第一趟：
* n4 T5 K9 r' G6 U3 c
第二趟：
, Y5 t' D  H& A' L$ V: T

5 c9 t/ J2 e: [第三趟：

第四趟：略
第五趟：略

9 N& U1 S" K% m7 w) U基本思想
$ s) n2 i+ V' z/ ?) q1 Z
与直接插入排序相比较，折半插入排序引入了mid，low，high，减少比较次数。
7 U# D( I5 x; n; p# _6 i0 ~0 ?取将有序子表中间值，若a[mid]>a[0] (待排序元素)，low=mid+1，反则，high=mid-1；
* A! q3 m# j8 C1 A) n' k7 }( j; Z找到比a[0]大的元素，均向后移一位，将a[0]元素插入待排序子表，形成新的子表。
  h' H* ^; d, N3 X# d$ X0 B代码
. `( P+ w+ Y2 C8 u$ G: J
: B* j/ @; `, k9 N#include "stdio.h"
$ R- C! H. ~; C) R& `- t0 T
" B6 _4 _  e8 K; atypedef int ElemType;
  I/ Q$ P0 D' E" Y
; U8 K) N7 G& j2 u# jvoid InsertSort(ElemType a[],int n){
0 Q5 V0 s+ d" {: b9 g8 X3 g0 T    int low,hight,mid;
    for (int i = 2; i <= n; ++i) {
8 ]) N( f7 L, D        a[0]=a;
        low=1;hight=i-1;
        while (low<=hight){
            mid=(low+hight)/2;
            if (a[mid]>a[0])hight=mid-1;
6 o) w, g( B6 R5 B, {+ V$ a3 P            else low=mid+1;
$ ~; o# X. X) A        }
        for (int j = i-1; j >= hight+1 ; --j)
) I% M6 [; h6 L3 H$ J9 A* m            a[j+1]=a[j];
        a[hight+1]=a[0];
    }
}

3 k+ ~  s8 N7 C& @% y/ l8 I4 U3 c
int main(){
    int n;
    ElemType a[n];
/ K' x6 ?/ ]+ c+ U$ D% H& }    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
1 o& B. J) y6 l: |0 [    printf("请输入%d个数：",n);
( g+ t0 s* {/ M, p. u( C) h5 c" X9 P    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
    }
" J6 ?$ x  v2 p, r0 \' J. S' |    printf("排序后为：");
/ ?: c8 p$ g+ u8 `    InsertSort(a,n);

0 ~& I% d% e- G- D  ]    for (int i = 1; i <= n; ++i) {
2 l& ^3 o  c; H7 ]) t        printf("%d\t",a);
    }
% U* y4 }1 X3 O' U2 r}
+ n0 a, s$ s1 o6 b" t0 D1 ~/ J3 I  ~
' F9 K& y9 H- v; {" L1
2 p$ {( x* X( c! b% ?2
3
4
6 y' R+ B% u# t+ }) ~7 H1 n5
6
( V: ^( _* T* M, m4 J# L) t" O3 A# W7
8
9
10
11
12
8 b* H& K+ d* e1 O: J13
& @* @$ `  O( Y& ]$ L4 s3 `0 @+ a14
/ N. C9 a9 o9 @0 \( V+ P$ Z( l- ~( O' P15
0 `7 z) u5 @: y: B! i( K4 {0 f16
17
" C2 H+ V9 Y, c$ |) ~) _18
19
) A# i0 z7 U& I20
21
- C) A. f# D8 F1 P22
, f% T3 M! \! V. H: m! W! z4 E23
24
25
7 f( g1 x4 r+ ^  o26
$ I: f( z9 [" {8 H" `* q% C27
  g9 s) F! }) q  X- `* \28
29
30
( g, }( |8 ~- _% Q+ A* T31
32
! {3 |: b( e1 ^# I' Q+ f. g. o33
34
35
, x9 h+ `3 H5 B% F9 W2 }. A36
37
! w& J8 Y/ D$ k: u! V4 Z8 V性能
. I6 o& }% E( R9 J* Q! q9 e
& z4 C) E$ n% L- b0 F9 h+ A( J空间复杂度：O ( 1 ) O(1)O(1)
时间复杂度：O ( n 2 ) O(n^2)O(n
% _) _- C, L1 g( R6 C2
)
稳定性：稳定
2 K6 ]2 x% u1 a1 H5 x. _适用性：仅适用于顺序表

' q2 I3 q. }% |+ c( w1 d6 n4 l- e1.3 希尔排序
图解(动图)


基本思想
2 _, X# P9 q+ ~
先将待排序表分割成若千形如L[i,i+d,i+2d,...,i+kd] 的“特殊”子表，即把相隔某个“增量”的记录组成一个子表,对各个子表分别进行直接插入排序，当整个表中的元素已呈“基本有序”时，再对全体记录进行一次直接插入排序。
6 o! e+ N5 k6 u$ T" ^1 W  g3 E* `
! O4 [* q0 p( ?6 X1 z3 _7 z" U代码
2 }4 H* N9 _& x6 }9 s+ B
5 ^) P9 X7 l. K2 g0 M: @#include "stdio.h"
+ Y6 C/ K: P1 ?% A
typedef int ElemType;

void ShellSort(ElemType a[],int n){
    int j;
    for (int dk = n/2; dk >= 1; dk=dk/2) {                                        //判断每次分成几个序列，只要>=1就排序
        for (int i = dk+1; i <= n; ++i) {                                        //dk+1：取到小分队的第二个元素（从第一个元素开始）进行直接插入排序
            if (a<a[i-dk]){
3 ]6 ?. w2 p6 E$ J1 c9 q+ B. j                a[0]=a;
                for (j = i-dk; j > 0&&a[0]<a[j]; j-=dk)
4 q9 W" u" c# r# c9 u7 K. A                    a[j+dk]=a[j];
                a[j+dk]=a[0];
            }
        }
    }
}
/ E8 W( M$ R! H7 ?  V& {
int main(){
, W8 {# l2 S* i! s) C- h    int n;
7 A4 L5 o3 e, f8 a8 {9 C8 H    ElemType a[n];
    printf("一共有多少个数需要排序：");
6 S1 a5 J5 ], o+ @7 r% z    scanf("%d",&n);
, x6 h: @+ K1 r4 E4 j5 z- B# i    printf("请输入%d个数：",n);
    for (int i = 1; i <= n; ++i) {
: w5 C9 X1 F$ G  Q1 g        scanf("%d",&a);
9 B1 k$ Y  A. F% h    }
1 z: S2 i+ G- B  @1 U    printf("排序后为：");
    ShellSort(a,n);

    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
9 i' x: `9 F0 m0 w4 u& ^9 q    }
* U) T2 G7 g- ]% o: D, g}
% I$ T% b' |1 g# u
  C8 b$ `! K. @: o& Y/ M1
2
3
4
5
3 E, W# U% P! }& u$ f( p% X: m$ T6
- ?3 p7 ^" o% y7
8
9
! q0 J8 ]: b$ Z4 j8 E: F10
11
% ?  H7 r& u( J12
13
1 k4 d( U4 b4 L4 s14
+ K$ R4 P+ L: E$ b1 t" S15
* C/ M7 {: V4 `, _2 _0 j16
17
18
19
20
21
) Y: W7 V- z2 i# R7 h22
! ~* N/ E: u% o. O. @: Q23
24
25
26
27
- e4 i/ d  U4 R: J$ W7 u28
29
2 ]6 v! |0 M7 f3 A- ]" [! p! V30
31
* m0 S6 l  _. N8 {+ _32
# Q7 J8 t6 d+ B! Q3 J5 T. y" ^33
34
性能

空间效率： 仅使用了常数辅助单位，因而空间复杂度为O ( 1 ) O(1)O(1)
, z- I& u# R7 h9 Q& a! L& Z
1 B& [1 I' G7 s1 B& N( [时间效率： 由于希尔排序的时间复杂度依赖于增量序列的函数，这涉及数学上尚未解决的难题,所以其时间复杂度分析比较困难。当n在某个特定范围时,希尔排序的时间复杂度约为O ( n 1.3 ) O(n^{1.3})O(n
1.3
)，在最环情况下希尔排序的时间复杂度为O ( n 2 ) O(n^2)O(n
0 v1 `  E: m  l/ [2 b; z2
2 \) E# O4 d6 O2 L! y )

% ~! J! b5 u% s4 G7 M0 n稳定性: 当相同关键字的记录被划分到不同的子表时文可能会改变它们之间的相对次序，因此希尔排序是一种不稳定的排序方法。


适用性: 希尔排序算法仅适用于线性表为顺序存储的情况。
/ n5 K+ e9 X& l( t8 c' v' P
2. 交换排序
2.1 冒泡排序
+ [3 {0 S  ?8 r图解
) |" Z0 I& {( ~5 T' y, y

基本思想

6 u, v+ f9 Q2 L) b( T' S$ Y, E从后往前（或从前往后）两两比较相邻元素的值，若为逆序（即A[i-1]>A)，则交换它们，直到序列比较完。我们称它为第一趟冒泡，结果是将最小的元素交换到待排序列的第一个位置（或将最大的元素交换到待排序列的最后一个位置)，关键字最小的元素如气泡一般逐渐往上“漂浮”直至“水面”(或关键字最大的元素如石头一般下沉至水底)。下一趟冒泡时，前一趟确定的最小元素不再参与比较,每趟冒泡的结果是把序列中的最小元素(或最大元素）放到了序列的最终位置……这样最多做n-1趟冒泡就能把所有元素排好序。
, Z. q4 [' q0 u7 \! U8 |3 M
) F/ a! N  x/ I0 J& |. ^( J- C代码
2 u; z2 o8 y( t! u
4 n" A) }8 _( B# Q- B+ ?& B方法一：将最大元素交换到待排序列的最后一个位置
7 W6 Z4 F8 B$ V$ m9 a) d
#include "stdio.h"
3 X6 s: }9 [7 T
) T! G# P# |! D0 J) Atypedef int ElemType;
0 s2 j, l% g5 V, v/ [' p: A
3 _7 w! n8 i: |$ i3 Q1 P9 [9 dvoid BubbleSort(ElemType a[],int n){
    bool flag;
    for (int i = 0; i < n-1; ++i) {
        flag= false;
4 c' y6 I4 B2 X1 w, l        for (int j = 0; j < n-i-1; ++j) {
            if (a[j]>a[j+1]){
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
" O) z! C$ h* L6 F" i9 f                flag=true;
            }
        }
        if (!flag)
            return;
    }
}
- N, j2 n  b  k: ?( ~. H
- j  M5 w% Q+ c) G
& A- u# S( @; N/ @int main(){
    int n;
# O* ^* E4 q! R; V: C    ElemType a[n];
    printf("一共有多少个数需要排序：");
# I9 V9 y6 g' m7 N- P    scanf("%d",&n);
6 }& ?5 I9 a4 X4 z    printf("请输入%d个数：",n);
. \+ K/ f, z/ i3 q5 ~% l    for (int i = 0; i < n; ++i) {
# |7 Q: F0 e# Q3 p  N2 `, U# s        scanf("%d",&a);
    }
! C& Q4 `2 {$ P3 D    printf("排序后为：");
/ S7 G; _* B- _) N    BubbleSort(a,n);
    for (int i = 0; i < n; ++i) {
        printf("%d\t",a);
    }
" J7 B# @% C: }- I}
8 c# i) E$ z2 j, g0 p
, |# R+ b+ T6 w: u" v: C# o1
2
3
) _/ H1 w, Y6 j. A1 C. S4
5
6
7
9 z6 _: J9 f2 d; Z8
0 ~5 r" u/ t' C  k9
8 h9 P3 F( m1 I$ f10
11
12
13
# E: a$ V) p( g14
: j, v8 T* x+ u15
16
17
! a  ?' _% S. b6 ]4 Z, U. U7 M18
19
6 P6 \! `* L/ F' K  q20
0 Z/ H) B, ?' y* S# G$ A# v8 O21
, b2 D5 I' |: n) `2 L22
23
2 G4 P$ s* A( E8 i* E24
25
26
27
28
. Y+ ?4 e( i  k0 h) d/ X29
7 Z" O8 R  D& z30
31
32
33
" l* O* R& Q' l$ b34
# y7 W1 Y$ f5 v1 d35
, t% r, a0 W0 b9 A/ K  E0 T0 ~36
& Z, t' _* n/ t; E37
- H& V% @' m) @9 U& |; c8 }+ ^运行截图：
. P7 L5 U" o- G: V4 K- p

! }: ]# L3 r+ M. ^+ Z- D2 Z方法二：将最小元素交换到待排序列的第一个位置
& C8 f: {2 T0 l
/ y6 [. j* D. z% o/ }# M: X#include "stdio.h"
% t; |2 h0 q6 f6 ]% T
' B% l/ d& s+ [2 gtypedef int ElemType;
- U  ~8 O) Z1 j2 g+ E/ {
void BubbleSort(ElemType a[],int n){
    bool flag;
    for (int i = 0; i < n-1; ++i) {
) m* h) x) U: M& t# A4 b" S        flag= false;
1 e. G  j- q; R; @) u9 {        for (int j = n-1; j >i; --j) {
            if (a[j-1]>a[j]){
                int temp=a[j];
7 h0 d. f1 b* o                a[j]=a[j-1];
3 h9 c* p7 ~/ g# `                a[j-1]=temp;
                flag=true;
5 E4 K) m; g3 q7 W8 c5 ]2 P            }
: {0 K: V; s! X$ N9 {: B# p% g        }
! m, P9 P! x7 v0 y9 e        if (!flag)
            return;
    }
}
( m1 X6 B- s- B* g4 L9 T: ~
* s' A( c6 n7 v1 d2 z% l9 Z  P/ f
int main(){
5 t( ^; e5 x% o5 ?2 K# T0 J    int n;
/ s3 m6 y* D; r. l% c    ElemType a[n];
    printf("一共有多少个数需要排序：");
4 f6 |" f  ^0 M    scanf("%d",&n);
    printf("请输入%d个数：",n);
, e# i; G1 [  ^+ M    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
    }
    printf("排序后为：");
4 W) O# X3 u* q, Q5 N8 g9 L; R+ ~' t4 o    BubbleSort(a,n);
9 `1 X4 F3 a# N+ \7 u  L) L# o3 o    for (int i = 0; i < n; ++i) {
        printf("%d\t",a);
7 b2 ^( B' C6 |* @( [    }
}

1
2
3
: I* A9 q% W) r: |' M( E4
' G# D9 o. @  f; j9 ]5 M6 @! L- y& b5
6
8 |  f* ?- ~3 a- T/ |. r7
8
. z4 h" a- n" X6 w9
( c$ |! A8 o( B* \10
) Q6 `# [4 g# e7 ^11
12
/ B: w8 V. x. q6 c13
14
& N0 I8 u: P9 S7 u) B+ |15
, L+ F" ], _. e. H' e3 J16
; o0 ^( s. ~7 \$ B+ I17
3 y  ?- y, J8 t" C+ Z. B% K" ?7 P' Y% P18
6 ^; n8 N6 q0 S2 @2 F, O1 S19
' a! d5 k1 Z, d# a/ Y' A- q$ u  v4 H20
* |8 c) @) I$ I4 |21
7 W8 r4 u/ T$ s6 k2 h  n22
0 z* g3 [* u" v6 R/ z% {) m2 ^23
& G+ @; |& }  A% q& P24
25
1 e. }9 R/ B7 E+ z6 C7 T26
) _5 T5 M7 _/ _( |$ M27
& d% Z# w: B0 F6 Z28
6 @+ j) G" y) s+ V3 i5 h29
+ y' _6 ]6 ?5 z7 Q30
31
32
33
34
- ]5 i0 e1 n$ _9 }) i35
36
37
运行截图：
# [7 J6 K, s% I: Y  D
. G& Q" R0 S  ~7 ~  g& D. l! {7 D
性能
2 ?) l& f' ~  t1 ]6 i: f1 T
% u: c* ~" D5 ^3 \" G- B9 w空间效率： 仅使用了常数辅助单位，因而空间复杂度为O ( 1 ) O(1)O(1)

' j' e$ n) ~: ^0 s: X, G时间效率： 最坏情况：O ( n 2 ) O(n^2)O(n
2
+ [# {' |/ g" A3 X- f% N" r/ N; Z/ j )；平均时间复杂度：O ( n 2 ) O(n^2)O(n
, f. j3 q2 h3 Z8 {7 X2
)；

稳定性： 稳定
, o/ ~. l8 ?% o0 E
适用性: 适用于线性表为顺序存储和链式存储。

2.2 快速排序
图解（动图以后再补）
第一趟的排序：

第二趟：
* }4 e, C5 l# P% C
6 {3 V+ k6 a2 Q/ W第三趟：

3 u3 r) t: Q- X0 N  w
2 U4 i; m4 t, d, O3 G: Y9 D% ^基本思想
/ M& F7 w/ q# N8 ~: ~
% x9 `7 y0 n) E3 f% f2 A, x快速排序的基本思想是基于分治法的:

3 g, F/ F: |9 ]8 \6 S1 f" S在数组a[0…n-1]中选取pivot：a[0] 作为枢轴（或基准，通常取首元素)
4 h5 Y  o& y4 p8 V, r通过对比排序，将pivot元素放置在k位置上，a[0…k-1]<pivot<a[k+1…n-1]，完成第一趟排序。
然后分别递归，将a[0…k-1]、a[k+1…n-1]子表按照1、2步骤排序。直至所有元素排序完成。
代码
9 V* h+ y' p6 f) j5 D; @! Y8 m
#include "stdio.h"
- {' W; \% z" [. C% g( [
typedef int ElemType;

: q9 h( y- Z1 C& N# ?: K+ q& ]int Partition(ElemType a[],int low,int high){
    ElemType pivot=a[low];
/ S9 X9 W, A& o' s& x) [    while(low<high){
. }0 d0 o+ d1 N        while (low<high&&a[high]>=pivot)--high;
        a[low]=a[high];
3 C/ o2 H( [! W8 I* a$ r6 \( @        while (low<high&&a[low]<=pivot) ++low;
2 T# S/ Z9 e3 Y/ A( Y" Z        a[high]=a[low];
5 m, ?: t- w$ k+ |    }
    a[low]=pivot;
    return low;
- p! W2 i' }5 M) x( V, c}

% j: e' X8 T, L- dvoid QuickSort(ElemType a[],int low,int high){
1 |" N5 g3 i5 w! l: C0 O8 m" o- v    bool flag;
& [9 u* ]' o$ W9 s' I1 m    if (low<high){
2 B4 A) a$ x2 c0 @7 T+ Y        int pivotpos=Partition(a,low,high);
        QuickSort(a,low,pivotpos-1);
        QuickSort(a,pivotpos+1,high);
    }
}
+ ]9 \) f1 n4 P6 X% j
) C/ [' ~8 Y3 [# _" T( S' Hint main(){
    int n;
    ElemType a[n];
' ?9 ?, l: V" E+ Z  V: V+ }# W    printf("一共有多少个数需要排序：");
& V# f' `/ K4 C    scanf("%d",&n);
  X0 G) t: X; V2 i1 H% m- w    printf("请输入%d个数：",n);
, l% u. G4 Z6 |8 ~0 G, d0 u5 z    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
( l- k$ `* d5 b" v( d    }
    printf("排序后为：");
" u. |+ Y7 _! F7 i    QuickSort(a,0,n-1);
    for (int i = 0; i < n; ++i) {
        printf("%d  ",a);
5 p! y- b* ?+ U! T- J) I  M    }
" P1 u0 Y& H$ Y$ U8 z}
/ X8 p6 x" C) `/ R$ Z% J9 e; @$ ^' t

1
2
3
4
% I& F' ?0 }1 D8 m) q. K! |2 j5
4 g" g$ E  k8 k0 _; D6
2 ?, s& \$ j9 M3 ~3 R0 N; Z7
7 ?# {" g) w) }* e8
) r3 O, ?+ T( a; A9 l& @4 u1 z9
- `( t2 x# ?3 g6 Q0 L" y2 I10
# z2 Y4 a/ X9 }# e1 d11
3 ]' K1 k/ d# b, `/ k: m12
13
14
15
6 z) X% W7 R' C16
17
18
19
' ~8 n2 L! S, @  h7 R20
# V: V9 D% k, ~0 @; w21
# P* ~7 c2 B5 x/ ~- P. J5 i& E! A22
( i9 l1 h8 C& K+ [! g8 e0 Q23
) M0 j1 {7 n5 g0 L" k5 Z. o24
& S/ }  o% t. W25
3 E. T0 @: r) N. b+ }26
1 ^0 w7 b- l- z! f- _+ t3 e27
28
29
30
/ k8 u  J) |9 g7 y* f31
6 ?; F& s2 ?1 A; h- E32
33
7 C. W7 ~% a8 i- G34
* r/ ]  W' G4 V* m/ U5 T% h35
36
- Z! X1 `4 G/ Z$ n/ t7 l37
38
8 M6 F* M; @4 B" H* X39
4 U1 Y: E' B+ X/ V6 |40
41
性能

& C9 J/ M* V. C" p: `+ M7 h9 g5 t3 u) Q时间复杂度和空间复杂度
稳定性：不稳定
/ f5 U8 x! J$ S6 O$ E" ~8 M
3. 选择排序
8 |' M9 ~: k7 s4 w+ {3.1 简单选择排序
图解
! h) E. i3 D2 r
3 V' W$ j5 K4 q
基本思想

  ~; p0 A% H% P在a[0…n-1]中，将a[0]设为最小元素，设min=0
  i3 w& ~- R* U* R3 i- q0 E在a[1…n-1]中找到小于a[0]的最小的元素a[k]，令min=k;
若min=0，则a[0]最小，不用交换；若min!=0，则a[0]和a[k]进行交换，第一趟排序完成。
在a[1…n-1]中继续进行排序。
" v0 J! m9 g# ~8 h/ z代码
6 e% N* _8 w: ]/ M! P$ Y
4 |/ L+ h( W: z/ j& ?, K! z, K+ X#include "stdio.h"
0 W* ?$ \/ b$ Z! r/ j7 w$ T8 H
typedef int ElemType;

void SelectSort(ElemType a[],int n){
    for (int i = 0; i < n-1; ++i) {
        int min=i;
        for (int j = i+1; j < n; ++j)
            if (a[j]<a[min])
0 A+ [$ I& z  \% p                min=j;
9 C9 S% v2 l) I3 T/ x        if (min!=i){
1 X# `0 Q7 b$ L. I/ ]            int temp=a[min];
! n5 Y3 ~1 G6 D6 D, U5 R* E            a[min]=a;
. T' L: j) ~. E. T- Q            a=temp;
7 [( b$ a2 O( L; w        }
/ `1 u1 [- T3 e2 P2 k    }
) p; M% I4 z6 J. N}
0 j! G3 L- O5 p( E$ G0 M
int main(){
6 E3 Y+ E, j! B" u    int n;
' H9 Z- c/ j/ a# _    ElemType a[n];
+ m- Z7 |% w1 v( r+ t0 M    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
2 A, Y' d6 f1 v% e9 }    printf("请输入%d个数：",n);
9 t2 Z& G4 S( T    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
    }
8 c; o; H6 {" S) g* `8 `, \    SelectSort(a,n);
    printf("排序后为：");
    for (int i = 0; i < n; ++i) {
        printf("%d  ",a);
+ V" H/ B; x- \2 g2 D, {    }
}

1
1 R# b5 p- C. s0 l3 v# h0 }" F. r2
- H( i& y7 e& J3
3 P4 J/ w' U  _  ~. q3 Q: X4
! e5 \) f( D  C" p. _5 X  \6 n( k2 _5
6 [0 J) W9 ~7 j2 e) V, c6
7
8
9
10
, G* _6 Y: B% b2 r8 x11
12
13
' B' n2 x+ h0 Q14
. U1 y2 }# |& u( j4 b% A: Y15
16
17
4 z0 x# p7 C( R% R  N2 m9 Y2 d8 Z18
19
: j4 m' s5 _! i: [) z20
21
0 y) c3 E! G5 Y$ e9 a) m3 H" e( u22
9 @- v& a0 y- V$ U+ S23
& s2 I) B' ~; n( {! N. ?24
# g2 {4 G6 [) }) d" O25
2 f% g3 y- Z: F4 ^26
( s# ~! S, L- ]) F4 h27
28
" Y* [- @- U2 _& n. j: x0 @" m' I29
2 B, y: d, _1 J$ U* ^$ E- p1 J2 P30
31
32
% [" Q# S, ?% P# {% v33
性能

空间复杂度：O ( 1 ) O(1)O(1)
# I) }4 X7 |# G4 g' C# E时间复杂度：O ( n 2 ) O(n^2)O(n
, D! g1 Q3 ?1 h; ~) w2
)
$ @8 r. e8 J5 i  p' g: z- i稳定性： 不稳定
% z. k( j3 \6 _! P! T% }2 f; z9 r
使用性：顺序表和链表都适用。
  `6 r: M! @# x6 M9 k3 \
- |$ F. a! x/ i/ c3.2 堆排序
看堆排序的点击这里！！！！

4. 归并排序和基数排序
4.1 归并排序
图解
# s# L2 n: }) c  ^% \/ S3 X1 i2路归并排序
; F: y9 u9 y  M) y6 ?. M

基本思想
4 }  r4 I5 j1 J3 H& E8 L7 h+ N& a
将待排序列分成长度为1的子表，然后两两归并，形成有序子表
( H: ^9 z* H5 f; ^3 u8 `
然后将子表再次进行归并，直到子表的长度=待排序表的长度。
; d: b5 H* c" r% c* j6 |  P5 T! w代码

, ~; x- g0 C* M8 L- e#include "stdio.h"
#include "stdlib.h"
  L7 M6 P1 w! [8 G# Z3 I; r
4 {( x3 ^& C, N+ ?typedef int ElemType;

. I1 s; k, ~. dElemType *b;
. y* P6 T5 t3 J1 s' d
/ V) `/ ?- w1 k5 Svoid Merge(ElemType a[],int low,int mid,int high){
3 p4 \' i9 A! }    int i,j,k;
    for (int k = low; k <= high; ++k) {
        b[k]=a[k];
" ^( h3 \" Q0 H5 r5 P    }
, I# |  N" u3 E$ s: l& d    for (i=low,j=mid+1,k=i; i<=mid&&j<=high; k++) {
7 x. ^4 X+ U# ]0 h1 a0 @# m        if (b<=b[j])  a[k]=b[i++];
        else a[k]=b[j++];
    }
* P/ p- r, b  b7 R, m9 Y    while (i<=mid) a[k++]=b[i++];
0 G1 C3 m. J* C! h    while (j<=high) a[k++]=b[j++];
}

void MergeSort(ElemType a[],int low,int high){
, O$ |: t7 M  E. U' U) i5 h2 a    if(low<high){
+ b7 P/ q! N: M, ]        int mid=(low+high)/2;
        MergeSort(a,low,mid);
        MergeSort(a,mid+1,high);
        Merge(a,low,mid,high);
& v6 [$ N) v. _( S1 Y8 u! I    }
}

int main(){
    int n;
" J/ f' {4 }/ e9 y5 U    ElemType a[n];
    b=(ElemType*) malloc((n+1)*sizeof (ElemType));
. c% {" `- e: e& y3 d- B  b    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
    printf("请输入%d个数：",n);
9 h: f. Z; j. }/ O    for (int i = 0; i < n; ++i) {
. I% L: v! E% {' ^% T. k9 e  K        scanf("%d",&a);
9 ^' ~8 `1 @; l1 U# J7 x- [7 s    }
    MergeSort(a,0,n-1);
    printf("排序后为：");
9 N  B0 k2 k0 [. [6 R    for (int i = 0; i < n; ++i) {
        printf("%d  ",a);
    }
}


1
! W* c; q- T* x2
1 K7 F- Q$ V9 {# C/ o3
6 A2 }$ @  S/ H& R4
5
6
7
1 V5 f! D+ s2 S1 U8
' K% ~1 h3 o7 o/ R8 Q" t9
10
11
12
; H4 h, X7 A+ j' f# Q13
; `  Y. N: ^1 P7 [$ ^# w- L/ n14
15
16
8 M& m9 f2 q; O* U1 g9 s( L6 W17
$ v1 r+ j- L; V18
19
' B, ~+ K  ^2 [1 V20
21
+ T; Q" a& s$ q6 x2 e22
23
, B3 w& g* C4 p- L# @# x1 l9 x3 j5 S24
25
26
27
28
29
; [7 ^% Q# s, ~; |! }7 ?0 k30
) E+ x' c1 p6 D( @! ^4 I6 n$ l2 I" b31
) Z% t0 b  f: I1 e# n32
33
4 @' F, |" p: S4 m7 s34
; L" ]: s) Y- N  m35
( W. \5 B+ }6 h$ i36
; Y: c9 l, b6 p# G2 X$ B0 Z37
+ F/ `! v- W/ R: F5 e2 y8 K38
( O/ w7 L- d1 a7 ^! X39
40
( \) ?2 H2 \; U41
42
" K6 k, L, E3 l& e3 t: p2 P7 j" ^43
6 C# A3 d3 J9 z1 ~. Q44
* j  s  z9 _/ e7 g3 F$ y7 B) A1 P45
46
性能

空间效率：O ( n ) O(n)O(n)      创建了一个数组b
时间效率：O ( n l o g k n ) O(nlog_kn)O(nlog
0 Z. f0 Z! f; J% _; Sk
) Q2 L. r- s# N$ t8 g​
2 d! ^: x! g# N. R. o n)  k指k路归并排序。
稳定性：稳定
- p0 w" V! y8 |& y) e) J9 g
& q; ?9 k, S# `2 y4.2 基数排序
图解


基本思想
$ b: A6 i, O8 n
, _( l: ^! J1 q$ l5 t+ e) Z0 q# M/ a将各个位数（个位、十位、百位…）进行对比。
" N+ u6 X( A; j' Z4 A% \$ E) |为实现多关键字排序，通常有两种方法:第一种是最高位优先（MSD）法，按关键字位权重递减依次逐层划分成若干更小的子序列，最后将所有子序列依次连接成一个有序序列。第二种是最低位优先（LSD)法，按关键字权重递增依次进行排序，最后形成一个有序序列。
- k6 i8 k+ h/ v5 V: [- x
9 k% P0 v2 C6 p4 ~性能

空间复杂度

  L( R/ o* y4 j* X  t时间复杂度


3 R/ m& B7 g4 W8 S, z& I稳定性：稳定
+ y; k* ~5 B  i& D
5. 内部排序算法比较及应用
5.1 整体比较
" {6 O% D8 d% ^- x

/ ~! X9 y5 f' v1 ]% I/ J0 ^) ?; x5.2 时间、空间和稳定性
; ~) ~0 h, Z- Y( j* q2 g

参考资料
; l# q+ |9 N# ?《王道：23数据结构考研复习资料》
2 W2 w6 P: w' Z( h! R: m! _————————————————
版权声明：本文为CSDN博主「仔仔木」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
( [! }7 a* V. ~/ q$ X; Q+ ?$ O原文链接：https://blog.csdn.net/weixin_46629453/article/details/126078678
' n, @  o3 g- D9 M  }  @

$ L5 ~! b1 G3 W9 \- }$ e  P$ e