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

杨利霞

数据结构：九种内部排序（动图+完整代码）
; e' t# z' y& ^+ n0 X) ?$ I
排序
! S$ j" i/ D; P0 _/ ^* @+ P) H1. 插入排序
. T1 Z% n' y0 n1.1 直接插入排序
! C! X. o+ J* a1.2 折半插入排序
$ b3 n6 d' e3 d6 ^) ]( u5 V1.3 希尔排序
$ i2 }$ b" Q) p2 w! b0 X2. 交换排序
2.1 冒泡排序
2.2 快速排序
& a% P; F9 V. e' H& f% R3. 选择排序
3.1 简单选择排序
8 w  k( S2 x* V$ z2 z% l( r! M2 J3.2 堆排序
! }5 ]6 |9 |! h4 ^* i4 o. @8 A4. 归并排序和基数排序
4.1 归并排序
4.2 基数排序
5. 内部排序算法比较及应用
5.1 整体比较
5.2 时间、空间和稳定性
参考资料

内部排序：是指在排序期间 元素全部放在内存中的排序。
+ h$ r* h" p' ?1 K) @内部排序算法的性能取决于算法的时间复杂度和空间复杂度。
1. 插入排序
1.1 直接插入排序
图解
/ L9 p8 }/ ~8 x! A6 t, z
* B% c/ _  k8 b4 g$ y& q7 O* K2 H
基本思想
9 c2 M8 |9 |( u4 p, J% [2 }' O
1. 查找a元素在第1 ~ i-1中的位置k
* K+ W& ?1 {8 X4 d3 W5 M# r2. 将k ~ i-1位置上的所有元素向后移动一个位置
3. 将a复制到a[k]
" Q. _4 d/ `' I" m( R1 C8 G! n

0 M# n( ^2 ?: \' ?" H8 {
代码

方法一：
8 `( J4 r# m6 i$ [9 d6 B' u
数组的下标从0开始，如上图。

# {" e6 U' M2 E# L% b7 S, t#include "stdio.h"

( k* u2 \$ {5 M' @( @4 J& Rtypedef int ElemType;
. e# V) l$ p9 d$ z! o
void Insert(ElemType a[],int n){
1 R2 B/ R9 b" G. e0 ^4 Z1 g    ElemType temp;
    int j;
    for (int i = 1; i < n; ++i) {                                        //假设a[0]是有序的数组，从a[1]开始进行插入排序
) I6 m6 @5 R1 `        if (a<a[i-1]){
            temp=a;                                                               
            for (j = i-1; j >= 0&&a[j]>temp ; --j)        //将k ~ i-1位置上的所有元素向后移动一个位置
                a[j+1]=a[j];
            a[j+1]=temp;                                                       
        }
    }
) t! z& M% C- g# [6 C. K7 r4 d% K}
+ t& j3 @6 r0 [, [  ~# K
) R5 t5 ~6 Z7 p* Vint main(){
    int n;
+ E; N, M: ]6 \6 u9 [3 v' D    ElemType a[n];
    printf("一共有多少个数需要排序：");
( t' F* x: t# a! L: b    scanf("%d",&n);
    printf("请输入%d个数：",n);
2 f5 _" V: X+ S& t( H( Q% ?; [    for (int i = 0; i < n; ++i) {
% r8 N5 D+ m# B        scanf("%d",&a);
" `) o. `0 f. W    }
# V, L7 C# a% x, B+ y    Insert(a,n);
    printf("排序后为：");
# U. h/ |" Q3 o* p7 q    for (int i = 0; i < n; ++i) {
3 d7 k3 _# w. }( F! o        printf("%d\t",a);
    }
' Q- v, ~" F# N7 a% K8 \$ ]" W}

) A% O2 j3 h) A# q1
2
4 X% Q" G/ I* \8 P! Y7 K5 P; @3
4
: z' P3 z) v8 ]& r6 X5 n5
" H1 B6 {7 g+ e6
7 y4 Z) \& G8 d. z. s7
6 @! B, @2 r8 h7 E6 p& G7 K8
7 ?/ Z, Q9 w" I5 P# k! b( C/ u9
10
7 O) \" }, ~, k! j, P11
: r1 s* P; c& X% r7 |12
13
  M& ?. W1 d6 }/ A9 X# L. t14
. w! V4 g& R) K3 g/ r/ T15
7 Q# |/ |( ~+ o' `' Z* W% ^$ o" p; x16
17
18
19
20
21
6 @( T) u7 q' l4 f4 h22
& ~2 V0 z# r% j* z23
24
) D! l- g9 A4 F+ @" W  e" p25
" G& x1 z6 t, |5 z8 C26
- Y2 t# F: D  `0 q6 {. R27
, H  D- R1 D2 p0 D% B28
29
6 ^. m  s9 ?% G# ~2 U/ E30
: i- H1 g5 C+ g" Y  C, i31
32
/ J, o# b! y! E- i方法二：



" K$ X8 ~/ d1 @- {: j+ l$ K#include "stdio.h"
; m& T/ T& M, W; d
typedef int ElemType;
) _$ u; Q2 j: z7 S
void InsertSort(ElemType a[],int n){      
3 a  _. J& ]# x9 t* t' }    int i,j;
1 n3 {1 q5 F$ \. _2 Z$ e5 Q    for (i = 2; i <=n; i++) {
        if (a<a[i-1]){
            a[0]=a;
            for (j = i-1; a[0]<a[j]; --j)
/ z6 g" ~/ {% j' L                a[j+1]=a[j];
+ o2 ~+ d' F5 k8 l* A            a[j+1]=a[0];
' l" X; }% O- {# h        }
5 B# Z2 G3 n0 K; |0 a4 G$ s    }
}
" _$ Y7 \6 O( E! r: a$ @" u0 W7 Eint main(){
    int n;
    ElemType a[n];
4 k! _5 m0 W! `0 A/ e0 W" Z0 g2 s% y- m    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
  o4 s# [6 u; A$ z7 j) M0 u    printf("请输入%d个数：",n);
6 c0 _; m  U& g3 j2 _6 p4 B3 a& Y    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
) R2 d2 y8 h: X% {2 Q" U* @- Z    }
    InsertSort(a,n);
- a& M6 v8 Y# P3 [9 |    printf("排序后为：");
    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
    }
}
% e7 Q2 `0 J  E7 k9 n' d0 o
1
1 d9 L% H+ r, @' a+ ?3 c2
3
$ k% w9 k& i1 W9 v: W! J. \- F. e4
* [) ?* `+ y8 l* n* m7 N5
% X+ ?( M( j, M- d3 C+ {6
8 W% L# i$ w5 g2 c7
7 e  P; ~1 W/ n6 L: K( J8 |6 t8
  i9 _, U* ^7 d7 W% g7 O9
9 s8 y$ [; i( o10
11
12
" n8 @1 P; f8 w/ H6 e8 H5 l1 l13
6 C' C  ]; X6 v14
15
16
# A/ ?. x8 Q. _8 b) {17
# j/ }* C8 T, S% T2 K2 e; @* u$ g18
19
20
6 g; ~* s5 \  s21
22
23
  Q; W8 [8 Z" Q, R24
+ {( g2 h! j% y" N! [: w3 j25
26
& R4 c' `" O$ e- U. F27
' H! w, M* q, S, {1 [28
1 [& U  Q/ Q- g: z" C. o) V1 p29
0 @4 o" m1 z5 h0 l) x7 h! C+ l30
8 J4 U: m4 {$ M算法性能
/ H* t6 q) F0 t! ~
$ }0 ^! V; R2 @空间效率： 仅使用了常数个辅助单元，复杂度为：O ( 1 ) O(1)O(1)
% ]& |! n0 D2 g4 q8 f
时间效率： 平均时间复杂度：O ( n 2 ) O(n^2)O(n
7 D! `) p% k! C9 q% `% A2
0 v/ m9 S/ U. D# }. p )
) R( x8 B) \, _& B
, k7 ~7 I: Z; C$ m* l, V$ U
稳定性： 由于每次插入元素时总是从后向前先比较在移动，所以不会出现相同元素相对位置发生变化的情况，即直接插入排序是一个稳定的排序方法。

) v/ r( P. Q* W/ O: \3 y& T适用性： 适用于顺序存储和链式存储的线性表。为链式存储时，可以从前往后查找指定元素的位置。
$ |, W1 w" @0 C7 x4 u- u1 Y
1.2 折半插入排序
* Z* x  T4 H  v8 g( v图解
第一趟：
* q8 Q8 q: _$ r! K3 `, N' p
) m3 n2 T- b6 a% B+ u3 g第二趟：
/ n/ z( O5 Z9 B
8 [: Z4 U$ ^* b# j9 M
3 r; s1 p3 v2 o4 p第三趟：
& L4 [2 c7 M6 N' r5 n2 B9 k
第四趟：略
! y% ?3 ]2 g: V3 f$ P9 R第五趟：略

7 f. ?2 H5 X8 o! z3 m' R( R基本思想
& @& P; v7 G1 G$ c* _
与直接插入排序相比较，折半插入排序引入了mid，low，high，减少比较次数。
" d0 T! V/ [# |. ^取将有序子表中间值，若a[mid]>a[0] (待排序元素)，low=mid+1，反则，high=mid-1；
. d. f/ g: o9 g& d; ]" n3 O4 |找到比a[0]大的元素，均向后移一位，将a[0]元素插入待排序子表，形成新的子表。
) `. l1 t' j8 O3 X% M  x1 o8 Q代码
9 E& ?5 u5 B2 Q5 p' f4 O* T* a
#include "stdio.h"

typedef int ElemType;
6 E( I+ A# C! }) O
8 w0 K% f3 v. I& Q- evoid InsertSort(ElemType a[],int n){
    int low,hight,mid;
9 }: r5 X: S# r( J6 a& H8 q9 q    for (int i = 2; i <= n; ++i) {
  N' n( t. U; f0 H* B3 l2 G8 g        a[0]=a;
3 Z. V$ Y2 g- M# n1 `, [+ K        low=1;hight=i-1;
        while (low<=hight){
            mid=(low+hight)/2;
            if (a[mid]>a[0])hight=mid-1;
            else low=mid+1;
2 f' T( h/ ]) z( _# V- v$ s        }
8 P9 R0 H, \+ |        for (int j = i-1; j >= hight+1 ; --j)
            a[j+1]=a[j];
        a[hight+1]=a[0];
: E, |8 d, x* `3 T* _. t    }
}
2 f9 o! ]( i  \. {& H
: ?( D7 Z5 b# l# _% C/ a
int main(){
, m' W& {* N5 e8 y1 o: i6 V    int n;
+ ~4 B! ~- _% J9 ]3 }- f# l6 F    ElemType a[n];
    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
    printf("请输入%d个数：",n);
6 K4 V+ w. G# {' A* ^5 G4 c3 S    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
    }
    printf("排序后为：");
: J# I* j3 P4 r7 o) k1 U    InsertSort(a,n);
0 [# ^8 D/ f6 `' k1 w0 F
& U1 Q, |3 v; v- l% ^    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
6 G6 s9 [- D1 [8 }, {2 Q( r    }
" H  ?& |9 X3 w" `; E) o}

1
0 h7 d2 x# b% I( C2
3
4
5
3 E) l5 u( v  M4 n2 k6 ^6
& D' l8 S" M0 A6 Q, M1 p! H7
8
9
- O% m  u2 e8 g: q" l! K5 O10
11
3 G. s& P( W3 A8 v- T* i! Q12
3 m* a7 t% C, }' q8 q13
14
0 P6 v( m0 S! t* O15
9 M& Z9 C, g0 E" _3 V16
+ c, Q7 Y0 D& z/ d  [0 n17
18
19
20
+ N2 C% I! |& a) ^. i( W21
22
23
) K% M+ U8 ^; {+ \8 [$ v/ {24
25
- X& s8 C$ S# _# t26
27
28
29
30
31
* h7 w+ F7 d7 H4 d9 q& X32
% [9 p# D. p6 ~- [! ~3 U33
2 h% a1 K6 `1 J9 r/ K/ i34
" D9 s$ p! g" ]9 j; L" p# i/ ?35
36
9 k$ i+ I; |9 B5 O# z- e4 o: ^37
( B" C4 h" ]! f9 `2 O1 v$ o性能
: i- H- T4 _* X
2 c+ B8 H& W; a4 ?空间复杂度：O ( 1 ) O(1)O(1)
时间复杂度：O ( n 2 ) O(n^2)O(n
# f. l3 _) V" n# R3 ]& Y2
% C2 a7 N8 D" H7 Z7 X  r )
- [1 z, {6 J8 Z+ b, l稳定性：稳定
% T) }! L  V" h& I4 f6 K$ A1 w: s2 ~! h8 p适用性：仅适用于顺序表
) y/ t8 x& ]5 Q
& x" z9 O7 v* q7 N" a1.3 希尔排序
3 g* |$ K- e' v7 w7 Y) L3 x图解(动图)

1 b/ [  w. E8 C" w  f. ^. O
1 s* [/ q% ?% x! A5 r基本思想

9 p7 b2 [# J" Z2 t先将待排序表分割成若千形如L[i,i+d,i+2d,...,i+kd] 的“特殊”子表，即把相隔某个“增量”的记录组成一个子表,对各个子表分别进行直接插入排序，当整个表中的元素已呈“基本有序”时，再对全体记录进行一次直接插入排序。
5 d# e* H0 F; T0 u: b
( |9 C4 x  L  G7 c& E- _0 n代码
8 H, D, K3 _& Y# g; ^" X$ |1 n
#include "stdio.h"
) K# y9 ~8 E9 Q. i
typedef int ElemType;
. D( w/ D0 m  |
4 _6 K8 Q% l  `void ShellSort(ElemType a[],int n){
) z$ s# k3 Q1 }' m, O8 J& n" Q    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]){
                a[0]=a;
                for (j = i-dk; j > 0&&a[0]<a[j]; j-=dk)
  K: @, \/ V2 Q( G6 M                    a[j+dk]=a[j];
0 F1 r# E$ X8 f" K+ c                a[j+dk]=a[0];
            }
        }
5 T7 i- a  x* y    }
}

+ \5 H8 m' L! B! i; E2 @int main(){
& a0 K. A  z4 d* V+ `7 Q7 d( ~    int n;
    ElemType a[n];
, e) @: G& f0 A2 g  J0 `    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
    printf("请输入%d个数：",n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
    }
    printf("排序后为：");
    ShellSort(a,n);
& n6 N' J3 H# L/ s, q
  T6 F7 Y9 T9 i+ n3 B2 |    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
    }
}
2 E0 n+ c0 j5 s
1
' B+ ^! j+ Y- H* {9 p2
3
4
5
6
2 s8 Q6 a/ V0 Q- v8 R7
& C* O3 n, f/ K/ M2 _& ~8
! D+ L) w* N+ H4 O9
$ S* p; `! P* |2 A10
11
12
3 F! k' a& u- X% w" `' |5 }2 b13
14
15
16
17
18
+ Z( Q0 A% A1 ]19
( ]9 Y7 L4 }, [) `. i4 k$ L- \6 d20
/ Q0 f7 q% d2 w4 J1 G7 t21
7 `( d7 g- R! s/ L22
23
24
! N$ s& H, c& e25
" q6 j; y; G' b( L, n5 l26
2 V' m: D1 l" O! z- Q+ P27
' I$ B, Y+ `* N5 _3 H28
29
30
0 @# H, v4 P4 R$ f8 m, Z  U) l31
32
33
34
* @( h+ H% P, d9 D1 |" Q性能

空间效率： 仅使用了常数辅助单位，因而空间复杂度为O ( 1 ) O(1)O(1)
2 o3 J1 X& u* n  Q
时间效率： 由于希尔排序的时间复杂度依赖于增量序列的函数，这涉及数学上尚未解决的难题,所以其时间复杂度分析比较困难。当n在某个特定范围时,希尔排序的时间复杂度约为O ( n 1.3 ) O(n^{1.3})O(n
5 {* K9 e; V* M$ E) f) r4 t( v1.3
) P. f8 D- B2 q: }, \9 }' s! [  {! l )，在最环情况下希尔排序的时间复杂度为O ( n 2 ) O(n^2)O(n
4 r1 S! b2 U* h; I: V: W2
$ P) E2 s8 w# T0 ~+ ?% {% N6 o- U9 K )
5 z( K5 R6 B2 r# v& t( d6 j
稳定性: 当相同关键字的记录被划分到不同的子表时文可能会改变它们之间的相对次序，因此希尔排序是一种不稳定的排序方法。
, I% H$ x% N- E8 \+ _6 I

适用性: 希尔排序算法仅适用于线性表为顺序存储的情况。
  n# e2 K; G' B* p
% j/ F' ?7 ^, {, N2. 交换排序
2.1 冒泡排序
3 R& b7 A" D% y/ M: t图解

5 U5 v# J4 u( L& `! O9 O
基本思想

3 ?$ L6 l  }3 K8 i1 T) h7 k1 u从后往前（或从前往后）两两比较相邻元素的值，若为逆序（即A[i-1]>A)，则交换它们，直到序列比较完。我们称它为第一趟冒泡，结果是将最小的元素交换到待排序列的第一个位置（或将最大的元素交换到待排序列的最后一个位置)，关键字最小的元素如气泡一般逐渐往上“漂浮”直至“水面”(或关键字最大的元素如石头一般下沉至水底)。下一趟冒泡时，前一趟确定的最小元素不再参与比较,每趟冒泡的结果是把序列中的最小元素(或最大元素）放到了序列的最终位置……这样最多做n-1趟冒泡就能把所有元素排好序。

) U9 D$ |* S/ V6 g2 ?& n+ @1 j代码
; y5 f! I* }. F) v
7 \1 D! B: J! i) u方法一：将最大元素交换到待排序列的最后一个位置

! M- E0 i- ^! V#include "stdio.h"
& F& S7 G* J2 o
typedef int ElemType;

, C7 j) z( ]7 n; E3 ivoid BubbleSort(ElemType a[],int n){
    bool flag;
    for (int i = 0; i < n-1; ++i) {
+ U# _( K8 Z0 ~, l. c        flag= false;
        for (int j = 0; j < n-i-1; ++j) {
$ n( x9 g2 q$ }4 m, a. m6 C5 W            if (a[j]>a[j+1]){
. I6 x( p2 w  A3 T3 ^* d8 C+ V                int temp=a[j];
* Y% i4 i1 Y, ~2 _- H                a[j]=a[j+1];
                a[j+1]=temp;
% K$ i( f9 T( _                flag=true;
" M  v2 D7 |/ x% Z" M' w! T            }
7 n2 a- |0 M# ^% R        }
, a( U7 Z8 X# R8 B        if (!flag)
. H. x% W% p9 f" D8 S            return;
$ f; j+ [$ u1 ?/ S7 L    }
}

& }! L6 _( v" q( w! V
3 i6 r  V, D4 Dint main(){
    int n;
  u6 K* o- Y7 G9 C: \* Z2 e    ElemType a[n];
    printf("一共有多少个数需要排序：");
& @6 z$ c3 ~: W6 M- S, G    scanf("%d",&n);
    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
0 g' m2 c1 N5 n1 e* M, ]/ ?# d' Y# X, w8 }        scanf("%d",&a);
1 g# R# S3 E) x  _- o' ~    }
    printf("排序后为：");
2 U/ Q7 g; ^1 @+ R    BubbleSort(a,n);
    for (int i = 0; i < n; ++i) {
        printf("%d\t",a);
8 y$ b6 ?5 [6 u5 \( @9 k! z    }
' e6 R( m- H; `. C. b* B}
9 A  T+ T; A; s8 P% M- y
* {  M0 H( a# l1
2
3
4
. A8 N6 G$ _. m/ k3 r, D5
3 N( m$ K8 z7 w2 n6
7
5 \6 v2 Y( Y4 n  `% [, _: d7 P8
1 H- D+ c9 N0 [) {. |! b9
10
11
12
% u% C, P5 k) o6 G+ M13
$ M+ V) ^3 Y; G& A, G14
15
16
17
: g' B8 ^  g. a5 R9 R$ J% ]% M18
- W$ n% R0 D3 R0 ~7 Q" S2 q19
: {. t  ?  d1 M# E' V' \% G20
6 ?" L0 v( P) r. G  b) ~  n7 u21
22
9 t, y% O, x( Q- Y: O! M23
0 X$ h  o2 Y" b4 p1 L& w4 A24
2 q- @% f. v  ?, C/ L) [' G; s0 U. s; X, O0 a25
* M- v% Q& Y, r9 U' l26
27
28
; E; l% X& E. A9 i; u! E29
30
31
1 d/ N  `$ `. n2 X' m32
33
34
35
36
37
$ l# F$ H+ s& G' {* |, }运行截图：
8 N$ q# `- `5 [. E" f% b: ?
$ A# T  b9 _: s$ e, o
方法二：将最小元素交换到待排序列的第一个位置
. ~; K9 A0 T7 \, u
' |  j% S5 t- h' V- M( R6 G$ O#include "stdio.h"
1 ]/ J+ `# m5 X. o7 h, c. I
3 u; V: _7 N0 j2 z0 G1 Atypedef int ElemType;
0 y) W, h* b3 @( x* g6 Q6 [6 l
void BubbleSort(ElemType a[],int n){
7 I) Q0 [3 v: |    bool flag;
    for (int i = 0; i < n-1; ++i) {
1 Y* {2 y% u' T  m4 ~, |, B, c        flag= false;
6 d( A' d" w. D# U" E8 V. |& p        for (int j = n-1; j >i; --j) {
, X& a6 D: y) c- @            if (a[j-1]>a[j]){
                int temp=a[j];
6 F8 @- S5 }+ g7 w" {0 P                a[j]=a[j-1];
                a[j-1]=temp;
# }; M# y% F0 g! V) ~                flag=true;
) ~) t7 S& \$ I            }
3 B( B3 N3 \' \; E        }
        if (!flag)
            return;
    }
}


7 }; L5 Y" H4 v, c# r3 K% d9 dint main(){
0 L! G# u) u2 k" A# v3 Q# w0 i1 g    int n;
+ T0 u0 v  |) r- F7 i. \    ElemType a[n];
6 t3 a: y3 V- S# {    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
0 r$ k- a* v1 h9 _0 ~9 g) S" f% |        scanf("%d",&a);
6 m  e" U7 q8 T    }
    printf("排序后为：");
# V! k4 p+ B2 ~0 T2 V    BubbleSort(a,n);
    for (int i = 0; i < n; ++i) {
        printf("%d\t",a);
7 |7 r# T- j6 l8 T7 c8 M" [    }
8 A) C4 A, i8 m, {}

1
$ N- {9 J4 N! S0 d# |2
7 w, P/ O$ Q: S  C: h* A3
4
8 I0 D- e) A* c  q& M; J5
9 d3 w6 Z. Z, u) K) |, A% k2 M6
! `7 c! Q+ q2 u5 T  D7
$ q0 {' P6 e& p+ A% D8 ]/ n/ t8 a6 E8
) ^" H1 W0 F1 [9 x; Z9
* ?1 l) o$ D7 ~& ]$ G) @10
2 o( x  _4 `4 ^2 Q! ~11
12
13
14
15
16
$ P" ]/ a# `+ a17
- x$ a" U9 b  M18
0 f4 o( f  Y6 G/ Q3 J$ T5 j  h: n% ?19
+ g- Q" w0 X- ^' b5 d20
21
22
2 H) }* w& K8 @0 v* s23
3 _( X$ c/ |5 ~2 f: u; k24
25
26
27
" p' t# [8 V- n' [28
, V$ h, k" f# ]29
* i6 F  R' N+ O1 U$ {9 p30
31
3 |- F: k! r* D, d" ?32
. w  G# i8 x+ K% ~3 ^9 G$ L, u9 q1 S33
34
35
36
. C. T6 ^% I1 N9 N6 J9 X37
# @: i% i- j" N" u; I) J运行截图：
! o8 t& h7 K! M$ \8 m: P$ ]8 D; I

性能
% w, D$ p5 }6 _+ e: [3 T% C+ I3 Y; X
空间效率： 仅使用了常数辅助单位，因而空间复杂度为O ( 1 ) O(1)O(1)
6 d5 D0 X" g5 F5 I' h9 {. _+ i* J# \- f
5 Q! Z& K) `$ K' Z6 O4 X. e- s时间效率： 最坏情况：O ( n 2 ) O(n^2)O(n
2
' i2 Y$ T, b: F )；平均时间复杂度：O ( n 2 ) O(n^2)O(n
0 o0 n% z; C2 d9 Q, e2
% c. _- g% {) H5 O$ G )；
+ ~9 q5 x, C9 B) V- Z
稳定性： 稳定
* k) c& _  m' {3 Y" F2 z
6 Q% A0 X% ~7 Y0 K# i7 i& Y$ _. L( }适用性: 适用于线性表为顺序存储和链式存储。
: y* Z1 }& \& o8 C+ T& a. z
2.2 快速排序
0 O$ O2 A6 G# L# E( B* E. o图解（动图以后再补）
% F5 ?# W7 G, ?1 |, K第一趟的排序：
$ e5 f0 S1 ^$ @$ G4 ?: S
第二趟：

第三趟：
, f% V0 n6 [' P2 E! ?
3 o7 k0 i' F. v, Y) @5 i8 M- S
( x) f. G7 n( I: @基本思想

快速排序的基本思想是基于分治法的:
, s; v& X4 M. T8 F4 |. s
在数组a[0…n-1]中选取pivot：a[0] 作为枢轴（或基准，通常取首元素)
通过对比排序，将pivot元素放置在k位置上，a[0…k-1]<pivot<a[k+1…n-1]，完成第一趟排序。
, X" V8 G% z& a* }: a% q3 f然后分别递归，将a[0…k-1]、a[k+1…n-1]子表按照1、2步骤排序。直至所有元素排序完成。
代码
7 G7 N1 g9 O, }  ^
#include "stdio.h"
1 I6 L* x; _& {5 a  ]" q1 b
typedef int ElemType;

7 f- [; B/ s" p7 U- p; T& F7 xint Partition(ElemType a[],int low,int high){
    ElemType pivot=a[low];
    while(low<high){
! v. l6 h# y# h8 q        while (low<high&&a[high]>=pivot)--high;
6 P  a' p' G2 L. ?1 F/ D/ `        a[low]=a[high];
        while (low<high&&a[low]<=pivot) ++low;
% l8 F9 S5 l  S2 A$ v( \        a[high]=a[low];
    }
* F0 T- f) X8 i/ I/ f- O    a[low]=pivot;
    return low;
}

7 I9 H) I1 p+ r' ^7 ~; B! S% L  Rvoid QuickSort(ElemType a[],int low,int high){
    bool flag;
+ [$ |: v" C- o- M    if (low<high){
9 |4 Y+ o. ~0 w; P% x- d        int pivotpos=Partition(a,low,high);
        QuickSort(a,low,pivotpos-1);
( k, i8 _$ X3 w  c- G0 }6 v0 A* P        QuickSort(a,pivotpos+1,high);
- S: V- W$ u, Z: j' E$ ^) B    }
}

/ M/ t7 M% R7 R* W: aint main(){
    int n;
    ElemType a[n];
    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
8 J4 M! U2 n8 L2 S6 m$ W0 y    printf("请输入%d个数：",n);
/ s2 a4 p- k8 T9 D% n    for (int i = 0; i < n; ++i) {
# I1 k' @- i- ~1 z% N9 h" R" n1 G7 r7 \        scanf("%d",&a);
1 C  o4 r5 t: q1 v    }
5 X7 N7 T, r% [! l    printf("排序后为：");
    QuickSort(a,0,n-1);
    for (int i = 0; i < n; ++i) {
! v6 m6 b5 A( T" U' j6 E        printf("%d  ",a);
    }
+ \" F6 j$ @' T}
) f/ _3 |3 Z) W% _

, Z. w/ E9 J+ ^0 Y0 ?( S% d& w1
2
) j2 t1 `7 t5 O" d8 j' C, N% g3
$ S  K! X, q& b6 p' s. K: E4
5
6
8 F9 e2 t" k* |5 q( |( r7
+ }5 _6 ]' D$ e3 o  m8
7 ~( N- r2 q, ~: L* O9
10
11
12
4 i5 [0 u* S; p, I  u, Y: K13
14
& Z' z! w( P2 C: L- m2 T: l8 a7 l15
8 r- M3 M$ L' W* Q16
17
18
19
20
21
" }  `+ J% s/ X: ^+ d) Z22
0 s% Z! X) X$ p5 m1 k, f8 C23
# q8 c' k* S0 ^# ^2 g- }0 o' u24
- h" u  o9 h# E" y25
26
1 _$ [& M( y9 U0 }/ S27
28
0 Z5 Q1 y& Z. [& k% T29
& K- E0 z3 h" y6 I7 U2 H9 R  R1 |" B30
31
32
33
34
35
/ r" }, d6 l: T* h: L6 p36
" d& k7 J  `- f* J! @( I37
& U4 s3 y9 `) b2 ?; ^3 y2 @9 D8 W  I38
39
40
9 _4 o' }  I! g3 h41
性能
* E* j" ^" W& B
( y- ?) s* [7 o" w! D时间复杂度和空间复杂度
稳定性：不稳定
* D, b5 f2 u/ b9 P2 U: Z
3. 选择排序
3.1 简单选择排序
) e- y* M' X$ N% M. \2 v图解
$ n  ]1 W9 b5 F6 }, x( I" T7 b, {3 L

1 |' _7 v, X! Q2 `6 s7 l基本思想
# O- `  T6 m1 ~/ G) m% Q
在a[0…n-1]中，将a[0]设为最小元素，设min=0
: o9 G4 @0 r( a: Z& f5 u# V& y在a[1…n-1]中找到小于a[0]的最小的元素a[k]，令min=k;
, R- f" i  t7 U3 E1 x' r若min=0，则a[0]最小，不用交换；若min!=0，则a[0]和a[k]进行交换，第一趟排序完成。
在a[1…n-1]中继续进行排序。
$ p" G4 z# z% _. s' h+ U/ p! |代码

#include "stdio.h"

9 O8 I/ f& F' I$ G& z$ A: u; D! \typedef int ElemType;
* ]) n4 b5 E( b- T* `) Q! ^
6 W# u- O( o  R0 Jvoid SelectSort(ElemType a[],int n){
    for (int i = 0; i < n-1; ++i) {
        int min=i;
        for (int j = i+1; j < n; ++j)
0 d& F( h$ R$ ]            if (a[j]<a[min])
                min=j;
        if (min!=i){
# |2 A% d4 }( a2 ]! l, x1 b            int temp=a[min];
5 }, j3 a6 u9 x            a[min]=a;
            a=temp;
        }
    }
3 o; g1 M2 K1 ~6 S/ R  O}
/ ]' V6 H( j& B1 j7 E
int main(){
    int n;
    ElemType a[n];
    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
- l* j& c; T+ S' T3 S    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
  o. f. m" ^, ?& D# k    }
8 T# u0 r" v; z    SelectSort(a,n);
; d0 Q0 T3 n" m+ X6 f    printf("排序后为：");
    for (int i = 0; i < n; ++i) {
! Z6 b- E1 M2 s% X        printf("%d  ",a);
    }
. u1 u1 k0 v6 x}
( a' e4 t: e0 p3 L# [
1
2
3 E2 g0 {0 s( v6 _+ E+ y- C3
. n! u$ f/ A: n2 [/ n4
5
! n' K# L8 Q8 e: [6
1 J5 O% _$ c  q- U7
8
9
10
11
12
13
( L6 \% Y' i' [14
15
16
17
18
4 Q1 {. }' q. f, U# l; k9 F19
20
21
22
23
" T1 f) ]; t1 J; {- O9 M% d0 B24
+ F3 S0 f! a/ F: U. d25
26
! S+ w, X2 e# H) X, o- S6 a27
' H6 o  h, v7 z" \* v8 J' z28
8 g- Z( q* C! J% g9 O  I. E8 f29
30
31
: E4 Y, ~$ |' B% ~0 c32
7 y8 K0 m- o3 K7 d5 H2 g, q33
性能

空间复杂度：O ( 1 ) O(1)O(1)
7 s; z* r$ u0 [6 t- P5 {时间复杂度：O ( n 2 ) O(n^2)O(n
- B6 H4 }( K6 X- t2
) z1 r$ O, l* H$ D7 H8 | )
稳定性： 不稳定
/ t4 o8 Q! C/ |" Z4 z
$ [; [: n* L5 H- i  I: h9 T使用性：顺序表和链表都适用。

3.2 堆排序
看堆排序的点击这里！！！！
6 W. ]5 b) e6 V) _) j
7 }5 p, o( u6 t' Y) [4. 归并排序和基数排序
# {( E9 e5 Z2 _& o, i! i4.1 归并排序
+ j  w4 u; x1 U图解
# D+ b- M) D: f* ]2 i) @2路归并排序
0 ]. Q5 |6 ~; u& G$ I: I

1 X8 \' V3 ?) t基本思想

# z& _: Q- x" V( C4 f将待排序列分成长度为1的子表，然后两两归并，形成有序子表
* m" A( b7 x/ a" o! P3 L$ b9 u
然后将子表再次进行归并，直到子表的长度=待排序表的长度。
' D: Q1 e8 I: t代码

#include "stdio.h"
3 {( V3 R( W5 `- D" H3 X#include "stdlib.h"
! I( m& U- k) w0 B1 l
typedef int ElemType;
9 K) J! p4 W. R9 G
ElemType *b;

void Merge(ElemType a[],int low,int mid,int high){
0 ~/ f) t% s- o3 G7 e    int i,j,k;
, N, R3 Y5 a) G6 A  T/ u* M    for (int k = low; k <= high; ++k) {
        b[k]=a[k];
    }
    for (i=low,j=mid+1,k=i; i<=mid&&j<=high; k++) {
        if (b<=b[j])  a[k]=b[i++];
1 S/ b8 Q: f' d# M4 `        else a[k]=b[j++];
- u# A! y7 W/ B' p; G0 d    }
    while (i<=mid) a[k++]=b[i++];
    while (j<=high) a[k++]=b[j++];
}
& G- a) Y& G$ q# Y4 {; e$ ?* M# C
void MergeSort(ElemType a[],int low,int high){
4 s) r5 b1 @* w/ `  O, D    if(low<high){
        int mid=(low+high)/2;
& Y, a, W6 \8 [9 O        MergeSort(a,low,mid);
0 L% }/ M6 ]5 Y  ^$ f3 H6 ?1 I. g        MergeSort(a,mid+1,high);
        Merge(a,low,mid,high);
    }
}
, o7 v, ~% D5 l+ F; R
int main(){
; R* J- X4 }$ B7 Y* C    int n;
  d, \! g$ B  Y    ElemType a[n];
1 Q3 o% O! g3 k1 A7 j* c    b=(ElemType*) malloc((n+1)*sizeof (ElemType));
, Q! s- ]# e* d* G+ F  h    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
( K% M- s+ b  U( b% Z# b' z& N  [: i# T        scanf("%d",&a);
    }
, l5 L6 W; j! G" v+ J, M    MergeSort(a,0,n-1);
& c' V" _- p  ]; A- O    printf("排序后为：");
    for (int i = 0; i < n; ++i) {
) f. Y2 \, S1 t2 y. p9 x+ v5 i        printf("%d  ",a);
8 u# v+ A2 m4 u# Z, w) l- b" O    }
. s4 u1 \" V4 d- f( _}
, |7 s0 u$ O: f

# z& ~, e+ S" f8 |1
, L4 n1 L+ I- D; V2
: ~1 u2 [: _9 Q( V# q' H3
  b, R/ w' @. ]- T9 J: m4
5
1 }7 @- T# Z$ X% x6 z2 M+ W" m6
7
8
9
10
2 f, J! S9 N/ A# y' J- M11
* V# s" C% \: b( R4 U12
13
14
; F, u3 r" t; w+ W$ [' ?! k1 G15
7 K. y/ i9 J; J4 o8 e* b16
1 D9 b7 H; a4 @* b0 S17
/ Q4 g5 j2 p6 P1 J7 L; N* n18
- Y( K# B: P, `6 m/ Q19
20
, A% w  T; d2 _% X* R21
0 T" A" P5 V% p, A! f9 M# f22
! X5 m2 r1 i) ^, k7 [1 O23
0 c4 S( s% F( G0 k% i  X+ h& k% O24
4 r- N2 c2 d. @2 K, T. M25
# k1 I/ [1 @. i1 a6 F  I26
27
28
$ {1 b7 C; ~6 ^, d* f6 L29
- Y& t! w$ |: q& z2 t4 i30
3 ^- W' V/ v% v5 g' X' M31
32
7 \5 N4 v1 j6 d, |% O33
6 i4 f3 `; Z, O4 z34
, L8 {' u- L& J1 K) x1 {' S35
/ |1 `" F( U+ p36
5 T+ X0 ?. r& s: x% ?& f37
38
3 r3 ]; t, e- W39
9 l& \- B- Y3 G" o40
, P$ C. D- d/ w/ X! F41
42
# y- [  z. h# ]43
1 b" D5 X* e* V# W# P- E, y1 W44
45
46
0 N8 _' q" `3 @性能
* k2 p) l& E) V6 o4 y
空间效率：O ( n ) O(n)O(n)      创建了一个数组b
时间效率：O ( n l o g k n ) O(nlog_kn)O(nlog
) V8 ]& F# G: b& T: i. v7 W+ s" F8 h3 xk
​
n)  k指k路归并排序。
稳定性：稳定
3 A% w' u3 R1 s+ ^. m9 s7 B
4.2 基数排序
图解

4 n: D0 P" s" N( d
基本思想

将各个位数（个位、十位、百位…）进行对比。
5 B5 M/ o4 w+ K. V/ ^) ^. @+ m为实现多关键字排序，通常有两种方法:第一种是最高位优先（MSD）法，按关键字位权重递减依次逐层划分成若干更小的子序列，最后将所有子序列依次连接成一个有序序列。第二种是最低位优先（LSD)法，按关键字权重递增依次进行排序，最后形成一个有序序列。

8 u2 s) L" r) Z2 t, i: Z' D, I! w性能
6 q( H$ M6 i4 F4 r; b( V
空间复杂度
0 v0 U) W/ t6 Y2 \
4 ^2 k+ q$ R9 H时间复杂度
  Q: c# F4 U2 g/ K8 q% {

稳定性：稳定

5. 内部排序算法比较及应用
) z6 p' V4 [4 \5.1 整体比较

  `1 D, z' T: v. _  R/ J
5.2 时间、空间和稳定性


9 s, w1 k' A; V参考资料
/ F- F7 I- W8 h# J《王道：23数据结构考研复习资料》
————————————————
) s/ X+ O& b7 C2 {0 y1 l1 G) h+ I版权声明：本文为CSDN博主「仔仔木」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_46629453/article/details/126078678