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

杨利霞

数据结构：九种内部排序（动图+完整代码）
; R9 e, u+ C+ r3 l
: V4 Z7 z9 @& {6 C8 ]5 Q: }排序
" P9 |1 J& y& Q9 L1. 插入排序
6 g8 D4 Z' T: i7 x1.1 直接插入排序
1.2 折半插入排序
1.3 希尔排序
2. 交换排序
  }* X/ P# R& Z$ a2.1 冒泡排序
, t9 Q; L( N/ k1 ]" j4 J$ t2.2 快速排序
' y8 p8 v! k& p- C% k( j- Q9 s3. 选择排序
3.1 简单选择排序
3.2 堆排序
4. 归并排序和基数排序
# t, ^5 i# D& A% c7 N+ m4.1 归并排序
4.2 基数排序
: {( O2 U# @7 C* x8 P1 W$ c5. 内部排序算法比较及应用
5.1 整体比较
* Z/ C' C) Q* e# T# i) p0 l: e5.2 时间、空间和稳定性
4 M# a) a: [8 h, w- `6 N参考资料

内部排序：是指在排序期间 元素全部放在内存中的排序。
) C" m8 J6 k# e$ @内部排序算法的性能取决于算法的时间复杂度和空间复杂度。
, J, e  w9 B4 ]& @3 J1. 插入排序
' E  S& \- F9 Q# e3 d1 |% A1.1 直接插入排序
图解


5 O2 v! R. n3 z- I基本思想
* R7 Z9 g* Q# J
* M' L5 P* b# j$ S+ G1 i1. 查找a元素在第1 ~ i-1中的位置k
2. 将k ~ i-1位置上的所有元素向后移动一个位置
3. 将a复制到a[k]

$ v& i7 T6 Y# I
  N  Q+ W+ h7 u( W
代码

方法一：

数组的下标从0开始，如上图。
9 g7 _6 {: i8 t
#include "stdio.h"

; |; W! L7 `5 `0 K# e& qtypedef int ElemType;

void Insert(ElemType a[],int n){
    ElemType temp;
    int j;
7 _, p- ~( L1 q- P( @    for (int i = 1; i < n; ++i) {                                        //假设a[0]是有序的数组，从a[1]开始进行插入排序
        if (a<a[i-1]){
3 R, z; z0 P6 n) a" m3 m: ]6 U$ Y            temp=a;                                                               
& k+ {' [2 e' t0 y; g% v            for (j = i-1; j >= 0&&a[j]>temp ; --j)        //将k ~ i-1位置上的所有元素向后移动一个位置
6 I1 t' O* P0 U, z" h' G+ G) i$ \                a[j+1]=a[j];
            a[j+1]=temp;                                                       
        }
    }
' y& {! `& Z4 |( X3 W}
: ]; R% T3 ^  l1 y, G, q5 r% y: x- ^1 O
5 I0 A' i. J; [5 d. Cint main(){
    int n;
    ElemType a[n];
) A! U  |, L8 w/ I  K    printf("一共有多少个数需要排序：");
4 k/ K  g1 X0 H" @$ K7 i% l& Y    scanf("%d",&n);
1 [, `/ M9 j) S. K" ?    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
+ G! `0 a9 y: @' ?' Q# [( T        scanf("%d",&a);
    }
    Insert(a,n);
! @9 ]7 Z9 z; f1 ~    printf("排序后为：");
0 o8 }' h5 P4 ^/ R    for (int i = 0; i < n; ++i) {
7 ]* G% ?& K' g1 h$ ]" Z6 {" L$ [6 v        printf("%d\t",a);
    }
}

# F* p: }% Z, v$ x  s1
2
1 o8 j7 }7 t- N$ D3 Q0 R6 c3
9 h* {) h9 `" e( N# W, r' x4
5
6
' ^- ?& Q* D& N( r& [2 O5 C: |5 D7
9 `! G) `+ x9 d4 l/ ~7 L8 W8
9
10
11
$ i$ H/ z- ?: A5 H. l12
( h) A& H9 c5 Y6 Q( e13
+ X: T* }) @+ S( k+ |& k14
15
16
17
18
19
! ^$ T* }4 n. x7 H( `) [3 p20
21
/ m& @7 S7 l0 E9 {+ w: r' ]22
23
24
25
: A2 r0 I5 }+ O- ~8 C! t% B26
27
28
29
30
31
1 W+ ?" Y1 ]% g4 H+ m$ Y  T32
4 O- V2 Y2 g& B6 _% U; [方法二：


, e7 y( D! f" Q% H3 b3 m+ m
#include "stdio.h"

typedef int ElemType;

  \1 ~" C- o& h  m* Z! B; \void InsertSort(ElemType a[],int n){      
: G) I) x, M3 Q! z0 t- S+ w    int i,j;
$ @& R4 y( l& T' L* G0 ^    for (i = 2; i <=n; i++) {
( u, N% v8 _! p% v        if (a<a[i-1]){
            a[0]=a;
            for (j = i-1; a[0]<a[j]; --j)
5 x7 C% f% z( ?                a[j+1]=a[j];
            a[j+1]=a[0];
, T8 Q: D3 S: u8 Y( G0 N& H        }
    }
: I2 s. O% E/ |5 f}
! T$ r# E9 h0 D5 u" z. qint main(){
    int n;
    ElemType a[n];
2 Q% f' Z! X7 }    printf("一共有多少个数需要排序：");
3 t* q0 [! b( M$ Y( I# ?) M6 K3 ~4 _    scanf("%d",&n);
3 n2 I( b/ ^* |  P    printf("请输入%d个数：",n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
7 w7 I7 e* r' q7 a    }
    InsertSort(a,n);
    printf("排序后为：");
    for (int i = 1; i <= n; ++i) {
, l. p0 L4 f0 p: I2 [# U        printf("%d\t",a);
7 p5 b8 s% H/ q' l# }! L    }
}
4 t! v* Y: ]' V9 z( ?- W7 U
- P  [6 D. L* e0 Z7 q5 R1
7 o' O, l  s) b8 t( l8 l. Q3 c2
. T( |+ ~9 ?$ h0 O" a+ R3
' }* [( Y9 ]& U1 M% l4
7 G( U3 V' C3 t$ c& i5
. Q$ b; F# P1 `3 [3 _6
4 s4 t& P$ D3 F6 O7
: X" r" r: @! ^8
" V2 B$ e+ W, a' N& r$ h9
/ g& O0 E- P5 j- y0 [' E2 E10
8 ?7 S7 b- T- M" s6 T9 _+ K' Q11
12
13
: q* h7 M) @, x14
15
5 m( m$ _5 V# D6 Q16
$ _5 }+ y; n' f17
18
, `6 u3 Z7 n; o& Z5 W19
. G. l! B8 }1 \9 ]# m20
0 M8 {- T4 D4 j/ q" o  G21
22
- H& h' b* z& P1 U4 }* t23
* O$ A" w/ [% O; e0 \9 b  l0 E24
4 f; G3 @6 }4 N25
4 r! z; X. `. j# V7 u# t26
6 a" d( h0 Z  X# t0 r27
3 c( j1 \4 Q/ U$ e28
7 m! I; ^" p* \29
30
算法性能
% @4 }( d7 |  g- z
* p8 L' c( ~  ?7 ~& D" r空间效率： 仅使用了常数个辅助单元，复杂度为：O ( 1 ) O(1)O(1)

时间效率： 平均时间复杂度：O ( n 2 ) O(n^2)O(n
2
1 x. N3 C, S" r )
, x6 f6 v$ V8 e
2 ^8 M# M0 c# p% y: L, g, p5 t
稳定性： 由于每次插入元素时总是从后向前先比较在移动，所以不会出现相同元素相对位置发生变化的情况，即直接插入排序是一个稳定的排序方法。
0 H9 }, R5 o$ ?# }  j' S" N) B
- H& ?$ {+ e7 t2 m% `8 O适用性： 适用于顺序存储和链式存储的线性表。为链式存储时，可以从前往后查找指定元素的位置。
& B  Y0 U7 J; c4 P" g- y1 r  i# K
" k4 K: x0 X( x% ?/ }1.2 折半插入排序
图解
第一趟：

3 j) g8 U8 i: l& o5 K第二趟：

$ e$ L! L8 J5 @- y
& Z" ?; l/ A* S' E4 b第三趟：

第四趟：略
第五趟：略

基本思想
% C- V' }8 y# q( Q2 T; h$ A
* T% T; ]  Z3 s( C6 c与直接插入排序相比较，折半插入排序引入了mid，low，high，减少比较次数。
取将有序子表中间值，若a[mid]>a[0] (待排序元素)，low=mid+1，反则，high=mid-1；
& Q9 P1 T$ D" H& ?找到比a[0]大的元素，均向后移一位，将a[0]元素插入待排序子表，形成新的子表。
1 C9 n* r3 x$ J- E0 E* X代码

#include "stdio.h"
( m) x% T5 ~- w6 X5 Y
typedef int ElemType;

void InsertSort(ElemType a[],int n){
0 u' ?4 @( M$ w) a1 _7 `) B, s/ w    int low,hight,mid;
9 _% I# e! n  C" B    for (int i = 2; i <= n; ++i) {
8 ~/ s  o. n% o: V2 D        a[0]=a;
/ p% U+ k! [  j0 e6 L( t8 d        low=1;hight=i-1;
        while (low<=hight){
- k: o+ m( |/ ~9 m4 Z2 Z            mid=(low+hight)/2;
            if (a[mid]>a[0])hight=mid-1;
            else low=mid+1;
# N* Q: S$ X! a% I        }
) [% h( n/ f3 J2 T' E        for (int j = i-1; j >= hight+1 ; --j)
            a[j+1]=a[j];
        a[hight+1]=a[0];
    }
+ E, Z. D3 P- E- C}

; \9 @, [; Q9 V5 h1 [% o! s; E
int main(){
+ _0 p# I+ j+ }" U8 K    int n;
    ElemType a[n];
+ L2 m+ j: i! I1 |/ w    printf("一共有多少个数需要排序：");
$ F* [& g; U' j9 f6 z4 u$ o, @- b- @    scanf("%d",&n);
; g# w" D% L1 l9 @: B    printf("请输入%d个数：",n);
& A: t/ Z1 Y: k7 {    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
! p) E$ m! x* M8 i6 i  |    }
    printf("排序后为：");
    InsertSort(a,n);

    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
# r; x9 v7 n8 _: X4 e* n. l2 Y    }
}
) K" E2 N- \: Q/ j  u0 E/ ?
. n4 D! k7 G& Q1
0 S8 w, M5 x; [7 N0 U2
4 T6 k. u/ k4 Y$ K3
$ q/ I( \, f; R+ X- C$ I7 m9 r5 m/ {4
0 T' h) t+ T; N! c5
, z" s2 @% e+ N9 Z8 @6
7
8
9
10
# t, }4 M7 ~- p, z8 O# n8 ^, E; ^11
+ }. x7 a1 i  ]( U6 f: L  M/ w3 y! s12
2 s; C; \, |2 V0 ?13
) B- F- Q$ M5 Z' h$ Q3 ^14
15
9 l4 p3 n8 v9 W3 [# q' a$ G* ^6 X16
17
18
19
  r6 z1 P  M$ d1 @$ W20
/ ^; j; c7 I) C$ G$ ?3 p21
( E: t6 u6 B: r6 f8 c- {22
23
+ i) f8 s7 U' ^* l/ ?9 e24
/ E" e0 j8 ]( f! M, |" L25
26
27
28
29
/ I* }! J3 {4 W( r- b30
. D" j6 R' l: H4 ~31
2 e" l( Y" f4 b) t( _32
33
34
1 I& Q8 o7 j+ u35
- V( r7 d2 F. n6 C9 T; O# b. ?, B36
37
性能

# Y8 V, j* [$ ], o& ~7 o( X( [空间复杂度：O ( 1 ) O(1)O(1)
时间复杂度：O ( n 2 ) O(n^2)O(n
0 i/ d& Z. B  [6 T; f6 S3 }( J2
)
: q& D% [# J* C: \8 `% h稳定性：稳定
4 @6 E) {, {9 }4 Q3 Y, s) D6 D适用性：仅适用于顺序表
2 j0 ~7 O3 r+ d; [! f7 q/ w
1.3 希尔排序
6 F! x( ]7 ~" k/ u: w% U# z图解(动图)
( ^4 ~' `$ L: A4 P8 S% t% ^
6 w& }1 z( W( L% ]
. I& h+ F% M* y9 q; A# j基本思想

( O; O7 R- w' o- g+ B; V先将待排序表分割成若千形如L[i,i+d,i+2d,...,i+kd] 的“特殊”子表，即把相隔某个“增量”的记录组成一个子表,对各个子表分别进行直接插入排序，当整个表中的元素已呈“基本有序”时，再对全体记录进行一次直接插入排序。
. D( \* h: L0 l* {8 I+ F; O# R
代码

' C6 t+ L. N0 `#include "stdio.h"

7 g! W" m* o/ k' i+ l4 p$ V- z* utypedef int ElemType;

  p0 L- _9 L4 fvoid ShellSort(ElemType a[],int n){
7 M" k  ]0 \! Y7 c+ H) R+ r    int j;
    for (int dk = n/2; dk >= 1; dk=dk/2) {                                        //判断每次分成几个序列，只要>=1就排序
        for (int i = dk+1; i <= n; ++i) {                                        //dk+1：取到小分队的第二个元素（从第一个元素开始）进行直接插入排序
1 m! z% j9 A: j# l! a8 [9 w            if (a<a[i-dk]){
                a[0]=a;
                for (j = i-dk; j > 0&&a[0]<a[j]; j-=dk)
                    a[j+dk]=a[j];
                a[j+dk]=a[0];
            }
        }
0 B* w, {/ A! ?/ C    }
1 x0 P* i4 M* Q}

( N  ?; {7 H0 b- m5 n% dint main(){
6 X1 p5 n& u. H% X0 p+ D9 d2 S    int n;
    ElemType a[n];
5 }1 j' I3 u" G) ]    printf("一共有多少个数需要排序：");
0 {* J' r  e% Y& ^$ N) b) F2 K    scanf("%d",&n);
& v8 U( @2 v. |- X% A    printf("请输入%d个数：",n);
  s' d7 G1 A' E/ q    for (int i = 1; i <= n; ++i) {
/ f3 E) w- a  ~; {: f        scanf("%d",&a);
5 g' \  ^2 G! E* Z" }" V0 N    }
    printf("排序后为：");
: k# c7 T. t. t) s  q  e1 E    ShellSort(a,n);
+ |  [. ^/ m% X! t% t0 @& }
    for (int i = 1; i <= n; ++i) {
9 w* u6 N) N/ v2 T" F1 s% q        printf("%d\t",a);
% n3 V! M  ]9 E% I" t+ K    }
}
1 }" F% `. {4 @- t
/ K6 ^" i0 p6 A  I6 M1
2
3
4
5
$ i0 k7 s; O" l+ O4 O& I6
7
8
9
: T6 G/ ]+ Q1 f, ]' {! O0 w' c10
11
12
. I  i) Q" O1 ^# M+ h13
6 W& T8 M6 o9 C: n% p& b: S9 U14
* l& u5 E/ R- ~6 `: e. S15
- t& E! `: \. [4 n0 x' a  m16
17
18
19
20
4 j/ m' n2 B: A* G- B21
22
3 B+ o- f3 h) D23
24
) }$ ^3 l) e) I& l25
# \, f  J4 x* x4 _5 I# q26
27
; G. U, ?/ K% A: U) Q) L28
. f: f0 q  d( w" F. Y/ [6 N29
( s% |. P# A+ O" L7 y6 V30
/ b+ l4 v7 }' y; z( g/ J) e; F31
, y3 n/ L7 H. Z' M32
33
34
. C5 k2 Z: K$ I3 k8 G/ ^9 ^( s性能

空间效率： 仅使用了常数辅助单位，因而空间复杂度为O ( 1 ) O(1)O(1)

, l  b+ ^+ g0 z0 \4 C& d时间效率： 由于希尔排序的时间复杂度依赖于增量序列的函数，这涉及数学上尚未解决的难题,所以其时间复杂度分析比较困难。当n在某个特定范围时,希尔排序的时间复杂度约为O ( n 1.3 ) O(n^{1.3})O(n
1.3
# j% k2 R( }" C7 O/ o* \ )，在最环情况下希尔排序的时间复杂度为O ( n 2 ) O(n^2)O(n
2
)
" q2 z$ [# u+ M+ ^! ^
稳定性: 当相同关键字的记录被划分到不同的子表时文可能会改变它们之间的相对次序，因此希尔排序是一种不稳定的排序方法。


适用性: 希尔排序算法仅适用于线性表为顺序存储的情况。
; P, J6 ^6 h5 I* q( ~& C
1 e4 M" Y$ L' @1 p% O' n2. 交换排序
. z, K* D; A) H7 E2.1 冒泡排序
" E+ E: [/ q9 X: k" f8 U! j图解


3 Y% R8 H; L1 k: m1 e5 R基本思想
5 x4 G/ x7 |1 L1 t
从后往前（或从前往后）两两比较相邻元素的值，若为逆序（即A[i-1]>A)，则交换它们，直到序列比较完。我们称它为第一趟冒泡，结果是将最小的元素交换到待排序列的第一个位置（或将最大的元素交换到待排序列的最后一个位置)，关键字最小的元素如气泡一般逐渐往上“漂浮”直至“水面”(或关键字最大的元素如石头一般下沉至水底)。下一趟冒泡时，前一趟确定的最小元素不再参与比较,每趟冒泡的结果是把序列中的最小元素(或最大元素）放到了序列的最终位置……这样最多做n-1趟冒泡就能把所有元素排好序。
" v( ?$ O& U9 d2 E9 P7 [' v1 Y
代码
8 R6 U/ @1 e2 b: X* z+ P
方法一：将最大元素交换到待排序列的最后一个位置

' L1 _. g0 l0 e! R$ M6 U2 S#include "stdio.h"
* G& U: J# _6 u
" Z! U4 H: H' u4 U+ r7 `typedef int ElemType;

void BubbleSort(ElemType a[],int n){
# Y9 F! r  n1 R4 R7 }    bool flag;
    for (int i = 0; i < n-1; ++i) {
        flag= false;
* v9 {& r& v9 A, w- G) j) p7 i        for (int j = 0; j < n-i-1; ++j) {
            if (a[j]>a[j+1]){
. u. l( C1 F# Y4 P/ w' e                int temp=a[j];
! S) P' r( Q# g: U( t7 G, ~                a[j]=a[j+1];
) {' c" y& h% a+ m                a[j+1]=temp;
                flag=true;
            }
        }
( v7 a% q  E  D( ?3 p2 n8 ^3 ^! D        if (!flag)
5 o9 f. h% Y3 Y" k8 ^8 [            return;
2 B: |( t' {  B5 R  s    }
}
4 [0 ^3 w: k9 X% O0 T

int main(){
/ N0 J0 A: X4 E    int n;
1 [* r. i. `6 r6 Y4 B3 t    ElemType a[n];
    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
+ ?. i4 W$ I+ j    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
. Q! e1 i) U' R& E% s        scanf("%d",&a);
  E  l# V6 D1 y, T& Z! {    }
    printf("排序后为：");
    BubbleSort(a,n);
    for (int i = 0; i < n; ++i) {
        printf("%d\t",a);
1 _1 z4 A" ~5 u. e) h! H: t2 q    }
}
2 R' H# j. z: t" J! f% c
1
4 @( y* j7 D6 I, H5 O) Y2
3
* c0 L3 ~0 S( E% |4
5
* o* r( e9 N+ W" G0 [6
+ j3 m6 W0 N( w$ O" G. e7
8
9
* \0 _4 \9 d$ E) F6 M10
11
- Z( d5 U) d8 U1 l+ U12
4 }$ D& v+ |& p$ x/ \13
* ^( M( C5 E, i* Y0 C14
" b. @5 i. i/ u# A( Y15
16
$ K) k/ G+ M# W17
5 o/ ]2 L5 |. M1 {8 H18
19
20
7 L$ E. B: t& [$ c- [21
22
23
24
2 g7 F; R" Q# h" [3 y+ F+ w" M  ^; C25
. @1 X5 C2 |2 x1 L# p9 r26
27
5 k( J5 @8 U+ Z2 W$ H: q28
29
30
. s5 J' z' l; s9 R7 B31
1 D0 t4 t/ Y8 P* g4 r  D, V# A32
33
1 }% _& t2 q+ k, ?8 H34
35
" K: s4 Q+ E9 @8 |' k  M/ @36
37
( K) f, a0 H* {& a运行截图：

# g2 q: t% t( q- L
方法二：将最小元素交换到待排序列的第一个位置
3 m4 P" o# j* v; m0 C
  G  m( i1 f' Y3 O4 C8 ~#include "stdio.h"

. d) ~$ o  |7 u- T- }6 Z# Ttypedef int ElemType;
  n( D  a* B1 T# J5 z; |% r2 z
void BubbleSort(ElemType a[],int n){
3 V% Y: P4 Z: s3 ]    bool flag;
    for (int i = 0; i < n-1; ++i) {
        flag= false;
        for (int j = n-1; j >i; --j) {
! ?4 i5 Q& M6 I& i9 {            if (a[j-1]>a[j]){
                int temp=a[j];
                a[j]=a[j-1];
                a[j-1]=temp;
+ \$ I. G8 l7 e- E: v                flag=true;
# M. Q0 w. u: f0 m" Y9 F            }
' t3 w9 E0 I% R& j1 n        }
        if (!flag)
$ a# B$ B( t. A; Y$ [  A            return;
+ @1 W8 O$ r9 J    }
}
2 Q/ Z+ }' N# q9 b1 Z: ], j9 R
8 e% }; `% O; [9 F
4 D) S! d+ u% Oint main(){
5 R4 b8 B! Y0 ~$ W    int n;
    ElemType a[n];
. K6 k8 ]/ M3 y1 Y* S, o    printf("一共有多少个数需要排序：");
# X5 m: D3 R) N7 u0 V    scanf("%d",&n);
    printf("请输入%d个数：",n);
: [( r0 D% Y/ r# U: G% M# {, c    for (int i = 0; i < n; ++i) {
( V  P& e9 S1 l        scanf("%d",&a);
    }
4 b5 `% A; O0 W5 J$ |2 W    printf("排序后为：");
2 P  F7 T+ L" e2 K* m* v$ u    BubbleSort(a,n);
/ b$ K9 d% K1 v' @0 k% i    for (int i = 0; i < n; ++i) {
% k( t; p6 N5 m. f8 c2 W        printf("%d\t",a);
    }
! }  K" E; }& |( w' J' S* r# J& g}

+ |4 m9 t! v0 {( ]: O1
9 M9 [# S/ S, }9 v( t2
3
& L7 M9 B) x& U0 Y" z: n, k4
3 x6 o: j, ]8 O0 s. Q5
( @3 a6 Z3 v) W6
7
% o$ d- L7 a' `0 H- ]2 I: @2 b8
  \2 c- B# L% l' y$ o" J) |9
10
0 i; ^* p4 H4 m' [3 P11
12
( ?' g7 o0 E  K. J; A* x13
- \" [; h! p' w1 M- r14
/ |5 J3 v. j" o  v# a. Q5 a15
16
17
1 O/ W/ A5 o) J2 \8 s* n2 m# c18
19
20
21
7 s5 @1 {8 L; Q1 G* j! S3 T22
# v/ ]( v# _. K0 v  f# ?23
24
2 ~4 A( k# Y. o) |. K$ C25
26
0 ?4 G" j3 c* `8 D# _4 M27
0 c! e- n; X  s1 {28
29
6 d" u5 s5 h) h" o- C30
31
32
6 R) ~7 e; b8 B$ N33
34
! S* h  k, Y9 [$ X1 d7 @* D& O( W" Q7 m- f35
) ]8 @! C9 z1 d9 }! q36
37
" V. B) f& p% |( T: q运行截图：

% {2 k1 W9 K6 g! Q4 c" W3 d2 a+ z
性能

空间效率： 仅使用了常数辅助单位，因而空间复杂度为O ( 1 ) O(1)O(1)

3 q# h6 y, p) p- N, {时间效率： 最坏情况：O ( n 2 ) O(n^2)O(n
2
)；平均时间复杂度：O ( n 2 ) O(n^2)O(n
2
)；

稳定性： 稳定
$ ~6 I! Z# `4 [
7 S! T- Q% }6 t, L% ~适用性: 适用于线性表为顺序存储和链式存储。
2 h% n+ v. a3 p9 Q+ N6 B9 U5 _
+ D" x" W; a4 u5 z2.2 快速排序
- o" V8 K* V0 [* K% H5 f: ?图解（动图以后再补）
第一趟的排序：

3 G, S2 T) w3 ~第二趟：
1 E4 N* u* Z5 q5 e$ P, {' L+ R
- s# o+ r7 }6 v) p1 k% S第三趟：

& m' J  D: N9 y; C! [
, r( l2 J9 Z4 l; q, P基本思想
8 {- t  q$ \" A' `& `# v
$ Y1 i2 \3 [+ E4 d! X快速排序的基本思想是基于分治法的:
% S" u& L  s- z  K- J, ~! D
7 p: F( W; X  m3 u, n在数组a[0…n-1]中选取pivot：a[0] 作为枢轴（或基准，通常取首元素)
7 h6 O, z6 S' T, z- Y' R! O1 P通过对比排序，将pivot元素放置在k位置上，a[0…k-1]<pivot<a[k+1…n-1]，完成第一趟排序。
% l  X) ?8 R0 H* q- V2 l然后分别递归，将a[0…k-1]、a[k+1…n-1]子表按照1、2步骤排序。直至所有元素排序完成。
- C  x( r2 W6 m/ U+ B- ]代码

#include "stdio.h"
7 T$ x/ N6 ^7 s2 K0 O7 j# X
) j; ]- X$ C+ l0 {0 O# w  atypedef int ElemType;
, k" z  g7 I9 b5 [( `
& S+ q$ D+ n  r5 G# w' aint Partition(ElemType a[],int low,int high){
1 n1 }- }3 u  F+ Z8 `. W    ElemType pivot=a[low];
    while(low<high){
        while (low<high&&a[high]>=pivot)--high;
        a[low]=a[high];
        while (low<high&&a[low]<=pivot) ++low;
5 U; ?/ u- S/ [, T8 ^/ R3 l+ ~        a[high]=a[low];
* S( t1 R4 C' `    }
: d6 E3 X- V: W) u/ T) g/ T3 S7 ]    a[low]=pivot;
    return low;
}

void QuickSort(ElemType a[],int low,int high){
. J7 c2 a* g7 o6 _% \7 |/ O8 e1 n    bool flag;
    if (low<high){
        int pivotpos=Partition(a,low,high);
        QuickSort(a,low,pivotpos-1);
        QuickSort(a,pivotpos+1,high);
    }
}
- z  H' c, Q9 [% E4 U% }
. s' l. C; b3 F0 E1 `$ Bint main(){
( V2 R6 c) Y4 t; X  p    int n;
6 P2 B, ~* k7 S) @: y    ElemType a[n];
# m$ _+ J; r' N1 y+ Y' l    printf("一共有多少个数需要排序：");
8 U' U. I9 I4 z+ _+ m, u    scanf("%d",&n);
4 E4 u9 O; P$ S/ y& a' |! n" [    printf("请输入%d个数：",n);
4 F6 J- L. L/ U" Q/ r1 i    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
    }
    printf("排序后为：");
. F* U4 w& S% M4 y    QuickSort(a,0,n-1);
    for (int i = 0; i < n; ++i) {
. U8 \& p" U( ?3 u3 W        printf("%d  ",a);
    }
}

; A: {& [$ t$ l0 X6 a
1
2
3
9 W% T- t& k" ~& T4
5
( S( p0 l; g/ h1 }/ d+ ~3 z6
7
9 E$ k& X9 @& O) g8
9
; K3 ?- l3 k; T( g& H+ Z+ w( H10
1 c2 n: H9 j' C$ H+ W: {) e11
+ U3 w3 ]9 W, L12
/ @. S' r2 M! M* ^13
0 @# ~/ {% s2 f. e14
15
16
17
18
19
20
4 u' a" c" f" E7 k3 w5 k% E21
. Z% F' W( l1 H+ n0 u" \5 j! n# A22
) h( r  S3 w/ w- P* Z8 k23
24
: ^& i7 z/ @4 ~* m% a! L: U& y25
26
% \$ f" w6 f) O0 x( H" N27
# N) E/ J" f8 U) n# y) X( ?28
29
30
& L$ @4 W) ^; o31
8 c1 U. W4 e* @' V( k32
  E+ L* N: M8 K6 }1 \* ^33
8 {* X# s) n  X% i34
3 V- c$ g5 S/ B, ?9 h, P# I35
36
3 {+ ^* j8 B1 i5 Q37
38
5 m( Q3 s$ @) q$ s  z( c7 {  ^39
9 S2 J  E9 i1 `$ F; v40
41
性能

- ?$ G$ Q: _7 e, E时间复杂度和空间复杂度
: @9 [3 C" @* p  x, [稳定性：不稳定

+ c. E6 p; ?( f9 d% y0 J: Z: f3. 选择排序
5 Z& t' m7 i9 F7 O( s$ ?3.1 简单选择排序
9 \0 \# [5 x" n. Y图解

) c4 M5 z) j$ H9 }  }0 X& I# x) E: O
2 c  V8 j& L; c, B9 n4 X基本思想

在a[0…n-1]中，将a[0]设为最小元素，设min=0
在a[1…n-1]中找到小于a[0]的最小的元素a[k]，令min=k;
( d; ]! G& s3 C9 e* j2 x  U若min=0，则a[0]最小，不用交换；若min!=0，则a[0]和a[k]进行交换，第一趟排序完成。
+ [& [$ S; V! r8 w在a[1…n-1]中继续进行排序。
  k, U/ h* j; E  v: f代码

7 j/ L" T+ I7 y. _8 b* h#include "stdio.h"
- K3 y0 a6 k) f) w9 A% Q
typedef int ElemType;
4 L  F! F# @$ K5 O; m4 e
void SelectSort(ElemType a[],int n){
    for (int i = 0; i < n-1; ++i) {
, u+ ?2 |$ o4 F# p" m" {' E; C        int min=i;
% ~5 x% J/ i3 l: p1 `: G2 U        for (int j = i+1; j < n; ++j)
            if (a[j]<a[min])
  v9 Z9 k/ l; o- J: \" V                min=j;
8 N' q) W* q7 @. l$ W, ^        if (min!=i){
            int temp=a[min];
' `) M* O' r1 a- |" Q, V            a[min]=a;
. ~: F4 E8 K/ g7 p' V+ B/ n            a=temp;
6 K* b6 S% F& v3 u        }
$ V3 Q/ ]# Z- A* i    }
% \1 a3 ^! V0 G}
$ ?* a$ j- W9 @/ e& }! e3 `
  X& y9 q/ D8 W6 gint main(){
! _4 U$ z8 m! l: f3 V- S9 f6 l    int n;
  p# B8 o) O8 D    ElemType a[n];
    printf("一共有多少个数需要排序：");
" [* _; K3 Q, M  e* d3 m( C1 ?    scanf("%d",&n);
    printf("请输入%d个数：",n);
" H: ?0 [* |. G3 x- b- H    for (int i = 0; i < n; ++i) {
  ]2 j2 k+ _2 k) L$ I        scanf("%d",&a);
! p( N5 E7 x: X. ^7 i3 K+ {    }
% W6 q* M- G$ `3 J2 o/ u) k/ G    SelectSort(a,n);
    printf("排序后为：");
    for (int i = 0; i < n; ++i) {
- G* M3 W5 {" c2 x3 E+ m3 f0 D        printf("%d  ",a);
    }
}
1 J  }$ W" C9 f# Q. T
+ y# t& e! p& A, Q7 \1
2
3
4
' w7 M! \  ]. Q3 c# }5
6 w1 T9 t% u$ ~9 J# Z( k8 e' G0 o& S7 C6
% x- c3 ~! \; i9 z" z& M# ~7
9 v6 ?8 d% Y5 K6 s8
* z/ o' h, o7 f1 L7 b$ u1 }9
( B  q9 h, u: E4 e10
% ?  |7 O$ c3 Y* S11
0 m4 N5 L/ c( u' ?12
13
14
15
, o+ J6 f9 @' v( b* @) k0 M! w16
: |. B9 e6 [1 H6 B9 o' e6 x6 v17
18
19
20
21
1 {2 _" e5 A* Q. D1 L7 B( f: [22
23
24
" O& C) n2 a/ B- ~25
) }* B( ^6 p: I  q0 G7 [* r& R26
) L$ @, @2 N5 A  P" U( p( P27
28
: M1 d8 `5 |# ~2 u& T29
" }+ j+ T. ?: `: c( T6 o30
7 r5 o, H. Y) S" j, m31
3 c$ @( O  P( D; V* {' m, ?: |* A32
# c0 f/ a* e6 M; l- Y9 c- l33
性能
% P0 T: M! D9 _: a6 @/ C
空间复杂度：O ( 1 ) O(1)O(1)
时间复杂度：O ( n 2 ) O(n^2)O(n
" N. U& L9 c9 K" q4 A2
)
稳定性： 不稳定

4 T5 z1 p5 f3 q1 v5 p1 i8 Y  z使用性：顺序表和链表都适用。
5 }% g# o6 n( `4 j
3.2 堆排序
" F. M3 S- r& l7 J, R9 S) Y4 X! D看堆排序的点击这里！！！！
8 u9 e5 i; }, c3 k( P
4. 归并排序和基数排序
) U$ ~/ [7 U: [/ ?9 v4.1 归并排序
图解
4 k4 C% W- ^1 O8 E/ W4 B2路归并排序
  V8 P5 z" V8 s! v( A

基本思想

: v6 c  E. [$ u- X( y0 z. q将待排序列分成长度为1的子表，然后两两归并，形成有序子表

7 W( m) W( C9 j3 C" C然后将子表再次进行归并，直到子表的长度=待排序表的长度。
% Q8 q$ R3 y/ P0 x- F7 ~; i; i代码
$ g. J0 d: h7 v# U9 @" U, \$ `
3 ~. a+ Y) D8 U0 e8 Z* ]#include "stdio.h"
#include "stdlib.h"

" U& K: {; I! [1 p6 utypedef int ElemType;
1 ^# _' @+ J" |4 V
ElemType *b;

void Merge(ElemType a[],int low,int mid,int high){
; Z* b( u$ X7 o; I, b/ l3 w2 W, X    int i,j,k;
    for (int k = low; k <= high; ++k) {
        b[k]=a[k];
! Q4 ?0 \" m+ _) H# Z; S    }
( B) ^9 d2 u" c; p! T' `    for (i=low,j=mid+1,k=i; i<=mid&&j<=high; k++) {
        if (b<=b[j])  a[k]=b[i++];
* e+ n  h3 x0 W& J; M6 J* @        else a[k]=b[j++];
+ a6 Y& R: `0 o& G  e    }
    while (i<=mid) a[k++]=b[i++];
    while (j<=high) a[k++]=b[j++];
}

void MergeSort(ElemType a[],int low,int high){
+ L3 _8 ^( B8 B, m6 E    if(low<high){
2 I. |  h/ c5 k        int mid=(low+high)/2;
        MergeSort(a,low,mid);
        MergeSort(a,mid+1,high);
9 X. ~- W. p, k! Z6 `, w  v        Merge(a,low,mid,high);
8 k  ~. I; q3 I# {$ R9 r& D    }
# _& m7 Y4 n  ?. o6 _6 d% ^}

int main(){
    int n;
    ElemType a[n];
+ u9 r+ N; j! u" o    b=(ElemType*) malloc((n+1)*sizeof (ElemType));
7 Z$ v+ T# e3 X$ E: u8 r, ?# Q    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
1 l; F: n% F& Z    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
- ?% r& @. Q; w) ~8 z: X: J# Q        scanf("%d",&a);
7 b1 }' ]* [8 B    }
    MergeSort(a,0,n-1);
    printf("排序后为：");
    for (int i = 0; i < n; ++i) {
8 W2 c( W2 A4 q3 Z% ^        printf("%d  ",a);
$ \; @% t8 j  ^( ]; [5 z    }
8 q: B9 U& L, w- z. F/ T4 i# Z1 f}


1
2
3
7 j( t! z' C5 e/ e; z6 y3 J4
3 d8 |# g* i  ~; G  D5 F- X% U- b5
: s5 \3 K% }' e9 O: d1 k  ]9 K6
7
8
9
10
; M: d# l9 [, k$ V) h* A11
12
13
6 d3 ^) X+ K* w- v14
- D! A) J: P6 ~, r) L15
16
# }# I8 j; s* a& s! Z& i, w* g- }17
+ q% C, A4 |. N: Y18
19
20
21
22
23
3 ~4 ^# x+ F+ z24
9 W+ G+ U( E# b9 e25
: J, n: h( B) `26
27
8 p( v* V6 [; r1 D" m! _9 M28
7 [4 U$ J' ?( ~29
30
31
% \: i7 A/ T; f/ b0 d3 F& L! c' r32
. {9 U) D4 i  |33
34
4 z( f$ K7 Z* Y: N* @( t  \( d# N+ ?) V35
# J( @7 a# C0 W. C" m36
4 {# P; x6 p4 s. t' X37
38
39
40
( h: Y* L. a( n  M# F41
9 e  c& `' K! u# K+ W( \$ T42
43
44
45
46
, ?% J4 M0 n, d( z. n性能
9 J) M- i9 d8 ]
+ Q& o. v# t& [) I2 `空间效率：O ( n ) O(n)O(n)      创建了一个数组b
% o" A! ~0 M8 K  u  ]5 k, r时间效率：O ( n l o g k n ) O(nlog_kn)O(nlog
k
/ g% @# D/ W$ @+ m* ]9 q​
) Z3 {3 U/ h/ C) L, ? n)  k指k路归并排序。
稳定性：稳定
6 r) F5 ^( ]0 d3 b
4.2 基数排序
+ H4 x1 A8 _/ {2 I: O- o# O$ r图解
  ]( y. e- s# [3 l8 H
+ S4 x3 F. e1 g, k$ \" j
基本思想

6 G. {$ {/ h1 m) i将各个位数（个位、十位、百位…）进行对比。
0 G7 K6 p# i) I) j为实现多关键字排序，通常有两种方法:第一种是最高位优先（MSD）法，按关键字位权重递减依次逐层划分成若干更小的子序列，最后将所有子序列依次连接成一个有序序列。第二种是最低位优先（LSD)法，按关键字权重递增依次进行排序，最后形成一个有序序列。

) o, W1 k( _4 D2 ~8 y性能

空间复杂度
8 b8 ~* f& G+ v
时间复杂度
4 d6 G; U8 I; q9 _: G$ ~! o
5 K; P% s1 ~) C8 N, k0 s
# i% i& a+ F9 u/ H稳定性：稳定
. g' h! C* S1 c2 f
( q( T) O1 s* v3 [: {5 y, R. N4 Q5. 内部排序算法比较及应用
1 |* H3 ^" X/ K) O5.1 整体比较
2 ?$ |$ b. Z: g% G0 g) n
/ b7 o1 e6 q/ X. S
4 S: j# p5 v! G* i2 K5.2 时间、空间和稳定性

+ {! g6 \7 x, d0 z
' d7 ?8 N  m$ u9 ]7 ~. Q( o参考资料
1 x. }( J. I! ]8 J2 b/ g《王道：23数据结构考研复习资料》
8 ~& \% Y" m+ }. }————————————————
' e8 M) P% Z! L/ L3 T0 B2 T版权声明：本文为CSDN博主「仔仔木」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
  T. w6 k9 o# Y% Y- ^8 F. W, B  W4 u原文链接：https://blog.csdn.net/weixin_46629453/article/details/126078678


  x2 a" R) ^7 ~9 {