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

杨利霞

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

排序
1. 插入排序
1.1 直接插入排序
" ~. z, O- K) Q5 \% m2 \1.2 折半插入排序
1.3 希尔排序
+ V8 J5 O* _7 g' S* D2. 交换排序
! U! ]6 S- j- N2 W3 J# Y2.1 冒泡排序
4 `# e2 Z+ w2 z  O6 O' y2.2 快速排序
3. 选择排序
3.1 简单选择排序
" D, s; d$ a' f& g5 g( M8 ?3.2 堆排序
/ o, w1 }7 _4 C4 m! J9 ^  [# d4. 归并排序和基数排序
% b2 [8 m+ N% d2 L' R7 y: b4.1 归并排序
& ^1 ]8 ~, x( Y6 o4.2 基数排序
5. 内部排序算法比较及应用
5.1 整体比较
7 t- \. ?6 j/ P5 T; x/ G- T5.2 时间、空间和稳定性
  ^$ h- I5 w+ j3 |$ s" P7 a参考资料
3 y: V! `. p6 M  Y2 Z9 w4 L
% j) T3 y& i) D: r- U+ e内部排序：是指在排序期间 元素全部放在内存中的排序。
内部排序算法的性能取决于算法的时间复杂度和空间复杂度。
! i% d3 {0 U" k: R1. 插入排序
: b' |' B4 Y3 n( F& G- b' j1.1 直接插入排序
图解
% [$ _, y: Q( |

基本思想
! F' W& U, L; E# G! }7 u: l9 ^
& O+ B1 q$ T: w1. 查找a元素在第1 ~ i-1中的位置k
" ], q1 I4 q# a  f9 r) X2. 将k ~ i-1位置上的所有元素向后移动一个位置
7 k8 n/ w8 D9 F# N3. 将a复制到a[k]
( E$ l. ?$ K5 b9 W: V3 y; p0 R" F/ U
" D$ f: ~1 R& Z( x) D

代码

  M8 E! X: X$ k8 g方法一：

数组的下标从0开始，如上图。
6 d. _' y& e3 [: u3 P
#include "stdio.h"
. x0 _# ^3 c: v1 B
# |: s3 Y& x- m; ~2 w& t* |typedef int ElemType;
3 A& Y5 I- X( M% e! i: n  D& p
void Insert(ElemType a[],int n){
3 N* {& K+ ^' m# E5 y    ElemType temp;
    int j;
    for (int i = 1; i < n; ++i) {                                        //假设a[0]是有序的数组，从a[1]开始进行插入排序
( R! N5 c/ j& O% b' ]        if (a<a[i-1]){
% I! q- r9 l2 i6 L, |            temp=a;                                                               
            for (j = i-1; j >= 0&&a[j]>temp ; --j)        //将k ~ i-1位置上的所有元素向后移动一个位置
* W4 c3 U3 {2 A- |% y# m/ u                a[j+1]=a[j];
% A) A5 |2 S; H' a# J            a[j+1]=temp;                                                       
        }
* N7 x1 @6 @; U3 n6 U* q    }
}

& D: {& I5 V) vint main(){
    int n;
    ElemType a[n];
    printf("一共有多少个数需要排序：");
% E* Z2 q3 V- Y    scanf("%d",&n);
    printf("请输入%d个数：",n);
! H7 m% |" ^" v/ b, K; A    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
    }
    Insert(a,n);
& X, c: z6 W- o- }( h& X    printf("排序后为：");
    for (int i = 0; i < n; ++i) {
        printf("%d\t",a);
    }
}

* i* b6 F# \$ i3 T. P1 u% H" M; Z1
2
3
4
$ ^: e3 P7 P8 D0 v2 ^5
6
7
2 j9 w4 X  H6 }; a  d8
9
& P8 P  w& c: C, Z10
6 C# V1 x  H, f. r0 t2 w11
12
13
14
& R% M9 r8 M; h0 C15
16
17
18
19
20
21
4 E8 ?- Z+ X; P9 ~. g22
23
24
/ F9 o. M  x! Q25
+ F, b1 _; [6 a# r* l) @6 @; |) [0 C/ m26
27
1 O: D) N# Q" e" ]8 ?28
29
30
: ?. A# K+ m9 `# |& E31
32
7 i/ z2 k3 a! Y% B8 N0 x- y* m方法二：
% ^7 y" A2 S! g. x
1 k/ t, |4 n# {& a! _$ l$ [
7 \$ y' n6 L7 I6 _$ K
6 v, z8 n/ e1 k#include "stdio.h"
4 D6 G1 I: P. Y( E2 L. t
, X& V, S8 o6 P! I: Atypedef int ElemType;
* E1 b  Z5 N. z+ [
& l" ]2 Y( @1 ~7 ?. Lvoid InsertSort(ElemType a[],int n){      
    int i,j;
4 Z, N5 Z; R  i9 P6 G    for (i = 2; i <=n; i++) {
        if (a<a[i-1]){
            a[0]=a;
! f- h  ?8 S: d2 F3 [6 Y            for (j = i-1; a[0]<a[j]; --j)
                a[j+1]=a[j];
            a[j+1]=a[0];
3 O( z2 q0 O7 I        }
    }
}
int main(){
0 J% n; L, N/ f+ P2 F$ ~    int n;
* Y! k% {1 `2 J1 e# Y! R0 L" d2 L$ p, p" q    ElemType a[n];
    printf("一共有多少个数需要排序：");
& S) K3 V: i" U  E    scanf("%d",&n);
$ b6 `' {" A- H% r. ^    printf("请输入%d个数：",n);
    for (int i = 1; i <= n; ++i) {
0 O( W- U. e( U: v( k        scanf("%d",&a);
    }
    InsertSort(a,n);
    printf("排序后为：");
. D! n9 t; K9 F4 l# s1 y* ^. S    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
    }
}
4 r/ a* U; D2 y5 b$ e* l
1
2
# r/ b/ y6 e' l3 w6 u" e3
4
5
6
7
8
; z2 c: d. I; \5 m7 J8 H. P9
10
11
12
: X  W6 q4 N. I7 m' o13
14
/ q+ d! }* e$ Z2 S15
16
17
7 e0 S7 ]6 |$ R; {- ~18
6 M1 a* u( U* X19
20
21
" |1 N+ S5 ~0 D2 P0 f1 E. n( ~) L22
8 P/ n' K# q1 A! Z. ~3 E+ B. [23
9 \4 \$ {) j% n3 W7 M# y- }7 Q  ]24
- o8 k, W) B5 ^: G* f25
4 C$ o; a6 u5 V. W, M26
27
28
# q" @2 i  }0 s+ T9 W- F3 q29
30
算法性能

空间效率： 仅使用了常数个辅助单元，复杂度为：O ( 1 ) O(1)O(1)
) M3 p5 N2 V/ Z& o2 p: K
时间效率： 平均时间复杂度：O ( n 2 ) O(n^2)O(n
( F2 b0 D2 W7 [% W* g% Z2
" C* W% \$ k8 k. d# T2 ^! t- c )

5 s' M  j. ?: [
稳定性： 由于每次插入元素时总是从后向前先比较在移动，所以不会出现相同元素相对位置发生变化的情况，即直接插入排序是一个稳定的排序方法。
( z0 z. G8 {: J: }
: f8 }' {& Z& T: V% ]) l* a4 \+ {# n适用性： 适用于顺序存储和链式存储的线性表。为链式存储时，可以从前往后查找指定元素的位置。

1.2 折半插入排序
图解
第一趟：
0 j' u5 [1 m) j5 k) x2 y: ]) M
6 l% C3 T/ x+ T4 M9 n2 H" f第二趟：

, x2 A7 {6 Q) w7 ?- z; d5 `7 K0 f
, w6 v/ t# Q4 ?- G' L& t. k! b7 H/ r第三趟：
4 y* ]. k9 U4 ]9 y$ T
, a: ^- \6 q7 C第四趟：略
第五趟：略
8 q8 t, e( G+ }* K  O
* U: j# Q- R3 ]基本思想

+ j" E, l# J- z. D0 L1 |5 d与直接插入排序相比较，折半插入排序引入了mid，low，high，减少比较次数。
  _# n1 r* o* ^( N, P取将有序子表中间值，若a[mid]>a[0] (待排序元素)，low=mid+1，反则，high=mid-1；
找到比a[0]大的元素，均向后移一位，将a[0]元素插入待排序子表，形成新的子表。
0 c! h  _' g8 ]6 G9 d/ i$ x代码
, |8 x& }' P3 ?" I' U+ f& ?
& Q* y% T, Q8 E#include "stdio.h"
5 R. y/ i. g2 I: A/ W0 ^: M( k/ T
typedef int ElemType;

void InsertSort(ElemType a[],int n){
    int low,hight,mid;
    for (int i = 2; i <= n; ++i) {
        a[0]=a;
- q2 P. Q) `: _, s3 ?( ]        low=1;hight=i-1;
' u/ h/ P/ U1 y        while (low<=hight){
            mid=(low+hight)/2;
/ }- \8 l  z1 @( s& S0 N            if (a[mid]>a[0])hight=mid-1;
            else low=mid+1;
        }
7 Q3 d5 g( y( w        for (int j = i-1; j >= hight+1 ; --j)
            a[j+1]=a[j];
3 P" d. Y6 a, H        a[hight+1]=a[0];
3 ]$ @/ o4 g1 g/ K7 E    }
3 ?2 W8 a- M9 u  l- g}


int main(){
    int n;
    ElemType a[n];
. o* @9 t$ A7 M8 d% x  R    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
' [- v" N- I; I/ C" V    printf("请输入%d个数：",n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d",&a);
    }
    printf("排序后为：");
    InsertSort(a,n);
$ ^+ ^9 U+ r, [, d6 s1 n9 D
: m; j# v' d) p4 M0 K& s# O9 x) Z    for (int i = 1; i <= n; ++i) {
        printf("%d\t",a);
" R# y9 H0 y6 A4 f) D3 @. ^3 @    }
) d& O5 f9 o' c1 ^1 T}

( t% O9 ^& N9 J$ ]1
2
3
$ W/ o! r* q: p. M5 f8 r4
& e: G$ ?' P" r! Z4 c! Z) ?5
6
0 z" A2 V+ @1 v5 X9 h6 l3 d7
8
9
) u: o! x6 h  K" `( T* U1 j10
11
12
13
14
15
* _- a1 ?( |3 F, Y; p16
/ l' p8 I. |. q17
7 U' p/ D- i- B* l, d2 i18
19
) B" Q# S8 a/ D/ N" d0 _' b20
6 Y4 }. g4 K# y- U. Y2 W21
2 j' T" w3 \# v. E, V/ s. d22
/ i5 }% V" f1 \% f7 F  I# h- H4 N23
24
25
26
27
28
8 _6 a5 `/ c  f% E: x' R3 E4 v* S29
30
31
$ f, ]4 @( m' s( G; P# Z32
33
' N6 w0 v' P. u7 m34
1 `8 K( V9 ^" K# \3 H0 f/ S35
, x, ~; n! d9 G% }36
37
- v; ?% `. F( z5 H3 w性能

( S+ V$ h5 ?( [  U/ N5 A空间复杂度：O ( 1 ) O(1)O(1)
时间复杂度：O ( n 2 ) O(n^2)O(n
/ X1 C2 a+ J" G4 V2
)
. u* r) ^& J0 x$ M2 r0 F稳定性：稳定
适用性：仅适用于顺序表

, _& y& t( [! d  _) e1.3 希尔排序
4 a4 L/ I; x- R% y7 i: Q0 Z图解(动图)


基本思想

先将待排序表分割成若千形如L[i,i+d,i+2d,...,i+kd] 的“特殊”子表，即把相隔某个“增量”的记录组成一个子表,对各个子表分别进行直接插入排序，当整个表中的元素已呈“基本有序”时，再对全体记录进行一次直接插入排序。

代码

#include "stdio.h"
4 h% _7 w( U& G: B8 @- J. a
( }. [3 G5 p5 Q* Dtypedef int ElemType;

1 h2 d- [" A* X8 {( pvoid ShellSort(ElemType a[],int n){
' o- u  y3 Z" l% G% c% v    int j;
    for (int dk = n/2; dk >= 1; dk=dk/2) {                                        //判断每次分成几个序列，只要>=1就排序
        for (int i = dk+1; i <= n; ++i) {                                        //dk+1：取到小分队的第二个元素（从第一个元素开始）进行直接插入排序
5 O6 O* _7 }! |            if (a<a[i-dk]){
# Q, N. l2 y  t  Q, H% g                a[0]=a;
                for (j = i-dk; j > 0&&a[0]<a[j]; j-=dk)
7 J0 C, u* v# f3 f1 m3 K                    a[j+dk]=a[j];
2 C- f1 o! p* n7 D: V( D                a[j+dk]=a[0];
+ t4 v* B/ }: `$ R$ `            }
        }
4 z! F8 C* }' r# a/ \0 C4 `    }
}

int main(){
4 v, U' g) |$ t: q& T. f    int n;
    ElemType a[n];
    printf("一共有多少个数需要排序：");
8 v8 d! E4 O& f" L; D9 d    scanf("%d",&n);
    printf("请输入%d个数：",n);
- `% ~( K; t2 q( I: n    for (int i = 1; i <= n; ++i) {
8 b" p- g% X2 H. V# Q% t7 H2 A        scanf("%d",&a);
" d$ r9 K; r( u8 j    }
    printf("排序后为：");
    ShellSort(a,n);
5 r# V$ B" C  `6 ]9 k
* @; h9 B# M3 ?& \    for (int i = 1; i <= n; ++i) {
) I  Z, F1 R+ D) e        printf("%d\t",a);
4 e* o) M' j" G( f8 k+ ?. }) x/ v    }
}

1
2
3
4
+ J" R: ?' Q- m- _9 Y& N5
6
( C' G. Z1 v- R7 J7 N8 m- z7
" _# K# a2 p% {& e' E. N& ]8
9
7 |/ j$ I" _' R$ z. @10
- H0 T/ u! C8 K8 ]! x+ w5 G7 D& F11
12
13
/ x, _8 o* b" Z; b14
15
16
# O' x9 q* k( l# h4 u: c17
18
: y4 a" N( W( [) R* ?( }5 F19
20
21
. k7 z8 |- K" I9 L7 p. g22
23
6 @6 t  y, X1 }8 l" k5 b2 V24
% M% w7 M. G$ y6 G25
26
7 Z" E% V! Z4 G: f0 Y27
28
8 z% w5 n* k) E7 e29
5 G4 T1 Z2 l  l5 X6 G5 E9 g- r+ D30
0 k0 S6 B8 _& D2 o% Q31
32
33
34
4 O- v' e/ S' I, z5 O性能
. h8 a1 e5 S' C9 T) o: d$ c# i* a
0 A5 t/ A+ U% b: Z2 O空间效率： 仅使用了常数辅助单位，因而空间复杂度为O ( 1 ) O(1)O(1)

时间效率： 由于希尔排序的时间复杂度依赖于增量序列的函数，这涉及数学上尚未解决的难题,所以其时间复杂度分析比较困难。当n在某个特定范围时,希尔排序的时间复杂度约为O ( n 1.3 ) O(n^{1.3})O(n
! T1 z. Q0 W1 H0 [! W0 O6 d1.3
) }) B- E# p2 _; v, M )，在最环情况下希尔排序的时间复杂度为O ( n 2 ) O(n^2)O(n
2
)

! _6 I) l. H. |7 c) K! `稳定性: 当相同关键字的记录被划分到不同的子表时文可能会改变它们之间的相对次序，因此希尔排序是一种不稳定的排序方法。


, z( `8 ^- U2 ^/ ], {* y适用性: 希尔排序算法仅适用于线性表为顺序存储的情况。
; R" t, x& f% p. R
2. 交换排序
( D/ ?$ t- ~3 x+ k; |+ A5 a& g( C. e2.1 冒泡排序
; }- L( i1 [. b2 i图解
; ]. o" f5 i6 y& r$ @! j3 I% a. h
; J/ i* k0 d/ r" n: |
基本思想

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

代码

" r! p( {+ ]$ ~" k3 e方法一：将最大元素交换到待排序列的最后一个位置
, K! M& _8 _) E/ B
! @' s6 |# \, G- i% y. I9 P4 T; {#include "stdio.h"
# _) z0 O( [/ e' P
typedef int ElemType;
  ~/ l% F3 W3 i' c- u9 b- _
void BubbleSort(ElemType a[],int n){
9 Q' F! A5 d, A    bool flag;
4 e( a/ x: _+ r! J    for (int i = 0; i < n-1; ++i) {
        flag= false;
        for (int j = 0; j < n-i-1; ++j) {
8 S% n: D5 t6 W: G            if (a[j]>a[j+1]){
                int temp=a[j];
                a[j]=a[j+1];
8 i0 R- ~- _& a5 f                a[j+1]=temp;
5 k$ D3 u8 |6 Y" \: p7 N8 L                flag=true;
- B6 S  ]) g9 ~$ `            }
9 b$ ?1 n) ], a1 C9 d$ f( @        }
4 D! H( ?4 M- i$ R        if (!flag)
            return;
    }
}
6 w# h, v" e2 w
1 D5 o" o! P5 s3 ^. s
int main(){
    int n;
1 B% W- ^$ P1 p# U* j$ _    ElemType a[n];
: A  |5 |7 ^6 n    printf("一共有多少个数需要排序：");
( d& K  H" r; H4 G+ j    scanf("%d",&n);
    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
$ ?" s3 J4 P' |) z- ?1 l' Q3 T        scanf("%d",&a);
    }
    printf("排序后为：");
    BubbleSort(a,n);
    for (int i = 0; i < n; ++i) {
, Z, L, j( ^- K  j' j7 R0 d        printf("%d\t",a);
$ ]& a8 Y7 @3 \$ F$ a    }
0 G' R0 L+ t7 P9 K; b( L}
# O0 ~, l, f+ W9 D
# ?1 }% _# }: r) `% B6 o2 [. @; g7 n/ K1
$ _5 H% w. A5 M) @3 x7 h4 P2
/ {" X' [: a9 a$ V, w0 E/ Y3
4
% \' a8 N: @& ~; M8 e; j% m; ~5
; c6 Z$ N  h/ N6
7
8
9
10
; @' s9 j/ ~. @' S% G2 {11
12
6 D) ~4 t- w+ [& W* J& Y( k13
, D- |; R: y% Y, e5 [  O( x2 v- E14
15
* Y( w2 \, c. G) }7 V7 ?* W! U16
7 p8 W2 O7 q# w: q8 X: U' b0 ~9 n4 t17
18
19
' ^0 ~( [' L7 h0 q# }5 K20
21
22
/ ]' c$ Y* a- \23
24
5 c3 X* G% l4 U% v, v. r25
26
27
0 F/ M( _, F0 K1 y8 `$ ~1 D3 q28
29
' J6 I5 X3 d2 `6 [6 g30
9 ?2 _0 K( [- Q9 g2 e9 b- G5 e31
32
33
2 @* k! V6 w  q+ a34
35
36
37
运行截图：
7 i& c4 a# b6 ~- K
/ |5 U# }0 \/ |# `5 }6 h
方法二：将最小元素交换到待排序列的第一个位置
2 T, o- e2 [, z  {# y4 `1 [
#include "stdio.h"

8 v, c2 K; R5 V) Ytypedef int ElemType;
( b0 X$ f" O3 z3 A  F6 f0 m
void BubbleSort(ElemType a[],int n){
% u0 X: ^4 t! S/ K( G    bool flag;
7 y% p1 s, y7 r# C& {& A2 {    for (int i = 0; i < n-1; ++i) {
! j) {2 P) r$ n9 @1 o3 C        flag= false;
& f4 A- Q4 `4 ^: n+ i$ f- E        for (int j = n-1; j >i; --j) {
            if (a[j-1]>a[j]){
                int temp=a[j];
                a[j]=a[j-1];
7 p- c  n7 A* b                a[j-1]=temp;
/ b' R3 O0 {3 {* T% `& ?& _2 V2 S                flag=true;
  r$ W& \3 b3 n' Q4 h& l            }
        }
        if (!flag)
            return;
    }
, c  {, Y: \2 Z! G7 N* a) m- V" S$ t}
8 w; v+ W2 i* T: o7 ?& L& s

) L- O; X* O0 J" ]8 v2 yint main(){
    int n;
    ElemType a[n];
; Q- o/ b, F1 ~( k1 z0 r$ p0 a    printf("一共有多少个数需要排序：");
" @- s$ E8 r& a/ V    scanf("%d",&n);
, }4 W: M! B8 U: |' {7 b" p4 G    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
  P7 ]0 y, W- a! g    }
* i/ g  p1 G% Y7 T; _# x3 s    printf("排序后为：");
. N9 z2 a' Q' p. c" U$ ~4 n    BubbleSort(a,n);
2 k( c2 K9 ~, e2 n; L, q! X    for (int i = 0; i < n; ++i) {
# Z, O/ `8 o, r. N& ~        printf("%d\t",a);
    }
; y$ k4 c( z! F}
( D+ E; l, _6 ], a% N
( K! `3 }$ q. }4 F1
2
3
4
5
6
6 g5 P7 C0 S! z3 y: r$ T! b: d* G7
8
' t0 c: b2 `" h4 x8 N- _9
+ \6 k8 _5 _- d9 U+ K7 |6 V10
11
" [3 R  d6 I, V; D12
13
3 {+ J# p5 l1 t5 {14
3 P8 e' `, o- v. ]15
8 o% P. `1 x) I. k16
: k5 s+ p- [7 `2 {" h9 A5 _17
$ R9 a. X' C& V  b1 u) F) w18
# ]2 [2 Y' G$ d" H+ `3 Z* |19
20
21
  K$ I- j" s' W) W22
23
  M$ y+ d$ P: [$ N# Z+ Q24
25
26
27
& U4 Z5 ?- M4 G4 F7 u6 a4 T0 z28
% ~) w' M9 `$ |6 t29
30
31
& i; e& _; m. M6 J# ~/ u7 M+ S$ y32
33
34
35
36
3 ]# }' t6 ^; }: k2 K: v37
运行截图：
* v' S& V) t  s) T1 b6 b
9 v5 m) T2 }( m5 C
5 e+ `) u4 _6 p" e性能

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

时间效率： 最坏情况：O ( n 2 ) O(n^2)O(n
! I9 @. y" J5 R: V9 R9 F2
8 `. h+ Q/ U# k( f$ b8 }, |4 T )；平均时间复杂度：O ( n 2 ) O(n^2)O(n
2
)；
% u& d$ D5 H% n9 ]
稳定性： 稳定

- Q# l6 L. s8 u适用性: 适用于线性表为顺序存储和链式存储。

8 c% W3 N% C4 G2.2 快速排序
图解（动图以后再补）
第一趟的排序：
3 J6 h* x# A5 `/ e( L: w
第二趟：
% W/ d, N0 W9 i2 _  Y, n
& v; D9 y. w' _! Y3 W" t第三趟：
: A6 a/ X: D8 o
- K! s( j1 K% M! L
基本思想
8 s2 w& E5 X7 \  K9 M4 F) X) z$ _
快速排序的基本思想是基于分治法的:
) ~+ {0 s. _0 Q
在数组a[0…n-1]中选取pivot：a[0] 作为枢轴（或基准，通常取首元素)
通过对比排序，将pivot元素放置在k位置上，a[0…k-1]<pivot<a[k+1…n-1]，完成第一趟排序。
然后分别递归，将a[0…k-1]、a[k+1…n-1]子表按照1、2步骤排序。直至所有元素排序完成。
5 j& j( ]; r% \代码
- H' }( Y) y: Z- d* b
#include "stdio.h"

typedef int ElemType;
6 D, g$ F8 c3 g9 C
int Partition(ElemType a[],int low,int high){
# g- P4 q# {  j2 r6 _0 D3 `0 V    ElemType pivot=a[low];
5 N2 p$ n9 w9 E    while(low<high){
2 n; l5 x/ b/ P! S        while (low<high&&a[high]>=pivot)--high;
: O4 B0 A" V9 y$ A9 m        a[low]=a[high];
* i/ O" q  H8 k        while (low<high&&a[low]<=pivot) ++low;
        a[high]=a[low];
; L# l2 A/ f' z$ }9 H- y8 N5 U    }
    a[low]=pivot;
' T8 L, w$ Z) G5 t7 F7 |' w' c    return low;
}
' I0 T6 O+ b% H, I
) ?0 i! O( S) c/ O9 _5 tvoid QuickSort(ElemType a[],int low,int high){
3 o) ~; v: @: `. F8 G& f    bool flag;
    if (low<high){
5 m/ q! l/ L, J; N        int pivotpos=Partition(a,low,high);
) T% @! u, }) a( K        QuickSort(a,low,pivotpos-1);
        QuickSort(a,pivotpos+1,high);
4 Q$ l: i3 |1 r2 ?    }
}

) Q! m- \4 v, g- Q- h9 Fint main(){
/ z! u! I. f4 C    int n;
    ElemType a[n];
4 |' B9 @9 M5 a$ }! r, ~    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
    printf("请输入%d个数：",n);
3 N$ j# r: Q! Q/ I" D1 p) g    for (int i = 0; i < n; ++i) {
) p1 o$ x4 a7 `% d        scanf("%d",&a);
4 K4 T- D9 Z; |& f8 ~( F% D    }
    printf("排序后为：");
    QuickSort(a,0,n-1);
    for (int i = 0; i < n; ++i) {
9 X  _: U% g, m& D7 }& S        printf("%d  ",a);
    }
9 o! a* e. ^3 Q, o* B& K' G}


6 |/ |5 }' W$ s. z  j- k* u' q5 b7 s1
2 E1 J' Q  e# s0 J2
4 ]6 C9 p, V7 x; a3
3 i* C2 s  o" I4
' S8 P3 `# L) a2 `" O5
: L; ^' J4 j+ q/ i3 C6 }8 T6
6 J* {) e1 X, H( A3 P7
( y1 ~1 H% ]# u- m. Y  n  T& T8
9
10
11
12
6 a, ^/ `0 Q; O( Q; g: F" ~4 `( u13
) u  o1 F2 Y+ Y5 I; g14
15
# j, I" o3 G" D  B6 C( |; I16
7 w1 H+ v  w* O17
18
  l, U  Y9 n5 t' p$ p# ?5 a19
0 R, W" V9 h( T: U20
# Y" y1 }" n8 X. x21
22
4 i! k0 ~' \) h# b, G23
# Z0 [+ e1 _1 X24
' X+ E3 h) w0 S0 e25
  j' h) i/ a; ^26
27
28
29
30
31
3 ^& F7 T" M! F1 t. Y2 Y32
33
% O3 A' C6 `3 v" `6 j34
+ t- I& J7 E' j9 l35
36
37
38
; E9 v2 _/ I9 \2 R* \39
40
41
0 I- p0 R. f- B性能

8 a' i5 q( n3 D6 ?. A( J时间复杂度和空间复杂度
( w$ X9 Z& A" }0 p6 Z5 s/ h/ E稳定性：不稳定

3. 选择排序
( b8 k* a5 g' r2 y3.1 简单选择排序
图解

) L* l6 U* Q; ^, r: q
) C1 u! \7 J) G, @基本思想

在a[0…n-1]中，将a[0]设为最小元素，设min=0
# V0 r  f* L& _3 z, _5 N在a[1…n-1]中找到小于a[0]的最小的元素a[k]，令min=k;
若min=0，则a[0]最小，不用交换；若min!=0，则a[0]和a[k]进行交换，第一趟排序完成。
& m0 T, _. g7 J3 g2 U  D/ Q在a[1…n-1]中继续进行排序。
+ |) M0 K6 u+ H! p. Y) A% r; ]代码

#include "stdio.h"
( `, ~2 w# c7 h
typedef int ElemType;

' ~- g2 ~0 c) w8 j& B2 P* K( nvoid SelectSort(ElemType a[],int n){
    for (int i = 0; i < n-1; ++i) {
        int min=i;
9 t# C) `+ C$ P" p        for (int j = i+1; j < n; ++j)
            if (a[j]<a[min])
. ?0 O3 K; U; t/ H( `) Z, i                min=j;
        if (min!=i){
            int temp=a[min];
, q" ?. \* E/ E1 H            a[min]=a;
, R2 D3 G5 o& x) P            a=temp;
        }
2 T1 b1 D5 A% r    }
0 b. X3 ~/ Q) p7 J}
( W7 j  Y2 I; Q/ Z# W  [+ w
$ ~6 F; I3 Z$ d1 \# Hint main(){
7 O! Z; U! z+ u$ {7 j5 V& r' p    int n;
    ElemType a[n];
    printf("一共有多少个数需要排序：");
    scanf("%d",&n);
5 Y8 C9 i9 C' T) k    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
) k3 B( f- x/ \5 E    }
3 u: }3 W/ b% ?: R0 j0 E    SelectSort(a,n);
    printf("排序后为：");
    for (int i = 0; i < n; ++i) {
        printf("%d  ",a);
) l. j4 g/ f  r* x9 D    }
}

/ z1 ~4 q& J, X* ^6 k1
! q% f+ n% r$ Z3 m2
3
4
2 Z6 l5 u0 h$ g. J5
6
7
0 s5 s7 w. c1 A* G* P/ A  ]8
: X6 m/ [. ~5 q$ p* m" b% E9
1 B6 G+ n9 V$ O3 _1 n10
7 t3 r& _. o2 M5 f3 \11
12
: ?! s; c( U- W6 w+ Y9 R13
14
15
5 t6 b9 K+ ^2 q16
17
$ t. i& D& J, z) D* M  k18
# `0 m' H$ v4 p1 f1 w. r6 q: M19
9 C7 w- F$ e. x8 Y& J: U0 O# r20
21
22
5 V0 T8 g6 P7 h23
4 y/ k* t2 C3 E& W- E) H. k" Z( |24
: y8 w& e4 F  c) {( o' q25
26
6 V- `2 y' Y) R& u27
28
29
30
) X$ m9 Q2 H: c31
32
6 `4 j, H! z" Y9 c33
' h5 v5 a- ~8 s  F- n性能
0 I7 g% F# r0 J& S" N; I% R
空间复杂度：O ( 1 ) O(1)O(1)
" U, r  ]4 c- A! {/ o+ F时间复杂度：O ( n 2 ) O(n^2)O(n
/ n# a7 p( w& w, w" t/ N2
% E! M  U+ `1 p# ]8 s )
2 R# H6 o" K7 S稳定性： 不稳定

% N: @) n/ B- {3 A使用性：顺序表和链表都适用。
; H) C; B! {% a% e. `
3.2 堆排序
看堆排序的点击这里！！！！
8 o" Q7 ~2 o' f7 v9 ]# W
4. 归并排序和基数排序
7 ]# E& f+ m6 p$ W4.1 归并排序
$ S$ x: o9 y, f1 |# q( }图解
2路归并排序
  F  [" r$ _& c) q6 i! Z6 I4 H- G
3 K" i6 E; q% |' _/ q
) E2 N' Y* ^) Z0 d  X7 Q1 E基本思想
! O! o- q" Z3 m# H/ \! s
将待排序列分成长度为1的子表，然后两两归并，形成有序子表

3 ^: l" @/ w- f6 z然后将子表再次进行归并，直到子表的长度=待排序表的长度。
代码

#include "stdio.h"
, M+ l6 d: A# r; h3 i+ b#include "stdlib.h"

typedef int ElemType;
8 F, e  N( V# @. S6 _2 f  I4 d( }
ElemType *b;

% p) x, ~/ p1 Y7 ?" ]( @- |void Merge(ElemType a[],int low,int mid,int high){
9 Z$ U, x% d3 `7 y# {2 i/ W    int i,j,k;
9 s7 H! `7 D! a' N( n# g    for (int k = low; k <= high; ++k) {
1 X9 W1 e) g) U& C9 C+ ~        b[k]=a[k];
) Y  T# h5 P3 I+ i) @    }
    for (i=low,j=mid+1,k=i; i<=mid&&j<=high; k++) {
4 ^. B% g8 k  b8 F  n# J) J        if (b<=b[j])  a[k]=b[i++];
5 I& L3 d$ Q! {        else a[k]=b[j++];
( {( r! ]. i* ]% D; v$ p0 ]    }
+ B/ ^/ ~; z" n! D    while (i<=mid) a[k++]=b[i++];
    while (j<=high) a[k++]=b[j++];
}

5 r6 r* o& H0 q- j+ lvoid MergeSort(ElemType a[],int low,int high){
+ G7 ?; p7 w, K+ V    if(low<high){
        int mid=(low+high)/2;
. W) |, B' C; Q        MergeSort(a,low,mid);
7 ~5 S: X2 E7 d  }, Y' \$ ]        MergeSort(a,mid+1,high);
        Merge(a,low,mid,high);
3 f1 g" p& f7 t: g    }
}

int main(){
    int n;
    ElemType a[n];
3 z$ [4 g4 q. ]( }4 H, j; S1 g    b=(ElemType*) malloc((n+1)*sizeof (ElemType));
; p, i; E1 X( |: X, p    printf("一共有多少个数需要排序：");
# u1 @, |$ \) J2 i5 b# A( _    scanf("%d",&n);
    printf("请输入%d个数：",n);
    for (int i = 0; i < n; ++i) {
        scanf("%d",&a);
$ V' R4 P7 D. I, _+ ^! u9 p    }
    MergeSort(a,0,n-1);
    printf("排序后为：");
8 v. _; g% k0 \  k    for (int i = 0; i < n; ++i) {
$ v4 }1 g& p5 ]/ J! ]        printf("%d  ",a);
    }
) G+ ^1 O. ^% w" P6 v' C5 j}
. {! C, H% q  t5 `) g
- z/ N) n0 ^2 `: m1 ^) s
1
9 `9 x8 n% c9 {  w; W2
3
4
8 {5 Z$ O( v; w4 ?5
6
7
8
5 V: a* X* ?) ^) G1 j8 M3 k9
* q& W# ^$ J6 @! w8 C. [' N10
, u' H8 V, v$ c* o# G, q* b11
( c6 H* q- H+ `: @: z* |12
13
14
" @6 ~/ R$ J7 G' ]15
16
17
7 w9 ?0 v/ u$ J  M/ {18
" z( T4 s0 y% s% R19
20
: Y3 T6 S, f0 o4 x4 c! K21
22
23
! u# z2 B) B+ z, K24
25
! ]; y& u6 ~7 `4 J) ?, Z7 d. L  L26
& d, o3 h% [1 l8 O  V# a) X, y2 _1 q" H27
28
" A. n' x7 @2 [( q) {9 X" a$ w6 q29
/ K9 s; S# z8 |. w8 A9 c3 S30
* |& Z6 \+ o- K& ~& _+ X; Z31
32
33
34
35
36
8 q  E; P0 L: a1 _# O. u9 t37
6 n+ N7 T* g1 p. E9 Z( u+ G1 b38
39
40
' p, L" `, _/ d" L" a2 I41
; a1 O4 I0 x! f4 q42
43
44
45
& Y' C( n2 p, R  g' c" @7 a46
3 Y0 i2 z" G& Q9 F% ?6 @性能

' B+ `! @$ Z. |! j# T空间效率：O ( n ) O(n)O(n)      创建了一个数组b
时间效率：O ( n l o g k n ) O(nlog_kn)O(nlog
k
​
0 Q0 U- ~" Z7 x9 E! g0 I" X n)  k指k路归并排序。
稳定性：稳定

4.2 基数排序
8 A; N, S5 ?7 }: ?* F图解
8 v3 ?% K8 B6 S4 S! L0 D* c1 W2 T

基本思想

1 G8 n2 y5 k9 \/ y+ n9 O1 L将各个位数（个位、十位、百位…）进行对比。
8 D# [) S. I% N4 o# Y( z$ F" S4 j为实现多关键字排序，通常有两种方法:第一种是最高位优先（MSD）法，按关键字位权重递减依次逐层划分成若干更小的子序列，最后将所有子序列依次连接成一个有序序列。第二种是最低位优先（LSD)法，按关键字权重递增依次进行排序，最后形成一个有序序列。
1 K' Z- [3 M! v  f
性能
, {% c0 ~) m, A% i. X$ A2 H
" R, k. W4 e! V1 c, x空间复杂度

6 Y# W' ~) x: _8 i: J& J7 k, h- B时间复杂度


; I# ?7 p2 H. e2 y$ ]5 f) g7 m' {稳定性：稳定
2 U# E- l: Z$ {3 U! e
8 q! }8 f% E, V& R: t$ r" N! ]5. 内部排序算法比较及应用
5.1 整体比较

0 g) U' o  _- ~0 i4 F: \
5.2 时间、空间和稳定性


参考资料
《王道：23数据结构考研复习资料》
+ y6 n5 F# z0 T9 T————————————————
版权声明：本文为CSDN博主「仔仔木」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
' @- ]4 k: b+ N/ X3 I" u原文链接：https://blog.csdn.net/weixin_46629453/article/details/126078678

! }9 T  `/ H  x$ Z
+ D% |0 e, R( W+ R/ R  d" {