数据结构与算法_排序算法_四个基础排序算法性能对比

杨利霞

数据结构与算法_排序算法_四个基础排序算法性能对比
( y6 C' L! [! ^0 [% a5 W$ v
分析一下冒泡排序、选择排序、插入排序、希尔排序等四个基础排序算法的性能，先逐个分析一下它们的特点。
! o: x% A2 B3 U4 E  M- `
一、四个基础排序算法的特点
1. 冒泡排序特点
相邻元素两两比较，并进行交换；其缺点是交换次数太多了，这也导致了冒泡排序是所有排序算法中效率最低的。
" x" o, P" [1 K9 T冒泡算法的改进：当某趟比较没有交换时，退出循环；
时间复杂度：冒泡排序的平均时间复杂度是O(n*n)，最好情况下时间复杂度是O(n),即数组是有序的。
**空间复杂度：**空间复杂度是O(1)，没有占用额外的空间。
稳定性：冒泡排序是稳定的排序算法，因为只有前一个元素大于后一个元素时才交换，小于等于则不交换，所以该排序算法是稳定的。
该算法每趟都能产生一个最大或最小的元素。
- N3 Q6 O0 `9 q
2. 选择排序特点
冒泡排序通过两两比较，每趟冒出一个元素放在末尾，而选择排序在逻辑上将数列分成两个数列【个人这样理解的】，一个数有序数列，一个数无序数列。
该排序算法思想是每趟比较都在无序数列中选择最小的一个元素和有序数列中末尾元素进行交换。
从该算法的过程中也可看出，选择排序算法相对于冒泡排序算法减少了交换次数，减少了IO开销，也就提高了算法性能。从下面的实验对比可以看出，同时对80000个数组进行排序，选择排序比冒泡排序的时间减少了一倍左右。
选择排序算法每趟也能产生一个最大或最小的元素。
时间复杂度：时间复杂度是O（nn），该算法之所以还是慢的原因是虽然比冒泡排序交换的次数少了，但还是需要进行交换，一旦涉及到交换就比移动效率更低，数组交换比数组移动需要更少的指令数，所以交换比移动效率更低。
空间复杂度：O(1)；
稳定性：不稳定，比如13 15 | 15 14 这趟交换完毕后，13 14 | 15* 15 所以，该算法不稳定。
: f2 s0 r' S4 R8 K: j( u( p
3. 插入排序特点
. O+ i! c! o* C6 G# X4 n6 y插入排序最大的特点是数据越趋近有序，那么插入排序是所有排序算法中，效率最低的排序算法。该算法的也可以理解为将数列逻辑上分成两个数列，一个是有序数列一个是无序数列，每次都将无序数列中的一个元素插入到有序数列的合适的位置，保持有序数列一直有序。具体做法是从无序数列中选出一个元素与有序数列最后一个位置开始逐个向前比较，如果该元素大于（以从小到大排序为例）有序数列中这个次数时，就插入到有序数列中的当前位置的后边，否则有序数列中当前的元素进行后移。
8 }3 I& l9 ?# y( U# i+ A* T2 V3 _  ~/ y时间复杂度：共需要n趟操作，假设都趟都会涉及到有序数列中数据的向后移动，所以最坏情况下时间复杂度是O(n*n)，最好情况下不需要数据的移动，或者很少需要数据移动，所以是O(n)；
空间复杂度：没有占用额外的内存，所以时间复杂度是O(1);
. d7 C, b' ^/ a1 Y$ D9 Y# m  u**稳定性：**该算法是稳定算法。

4. 希尔排序特点
2 F( R1 T+ l) V) B' F8 a5 ]+ I插入排序是数据越趋近有序，插入排序的效率就越高，因为不需要进行数据的移动；希尔排序对插入排序进行了两个方面的改进，分别从“减少待比较元素”和“基本有序”两个方面。从减少待插入元素来说，将整个数列按一定的增量进行分组，这样相对于整个数列来说，带插入元素减少了。从“基本有序”方面来说，对于每个分组进行插入排序，这样对于整个数列来说，整个数列逐渐变得基本有序。
/ s% \3 A; Y2 Q  o时间复杂度：希尔排序的时间复杂度取决于增量，不同的增量时间复杂度也不同，但是没有一种最好的增量序列。大量实验表明，希尔排序的平均时间复杂度是O(n^1.3)，最坏情况下是O(n*n)，空间复杂度是O(1)
5 I, q; {& I$ _$ J. a) C' Q稳定性：不稳定。
: {* D+ z% H# I
二、性能分析代码
// 冒泡排序：
& R7 |1 x% ]! J" a% S// 时间复杂度 O(n) * O(n) 最好情况下O(n)，即比较一趟后没有产生交换
, F" o( o: J+ C+ o9 h// 空间复杂度，O(1)
void BubbleSort(int arr[],int size)
{
        for (int i = 0; i < size - 1; i++)
        {
6 e! y% e2 R& G1 E' X; X                bool flag = false; // 优化:如果某行不用进行交换，说明数组已经有序
                for (int j = 0; j < size - 1 - i; j++)
                {
                        if (arr[j] > arr[j + 1])  // 稳定算法，
& O8 m5 Z. q7 B8 y. o+ M                        {
                                int tmp = arr[j];
* X" X; k2 ~. U! ^1 y                                arr[j] = arr[j + 1];
" Y1 r, ]6 o7 \' {                                arr[j + 1] = tmp;
0 G% C& s9 q& N                                flag = true;
9 E, m) \3 O$ g; T' D9 a                        }
) D/ K) s: {( S/ G5 I( H                }
                if (!flag)
                {
                        break;
                }
        }
}

// 选择排序
// 时间复杂度：O(n) * O(n)
; U& Y- e% z( @// 空间复杂度O(1)
- l! T/ k! E# a7 E) T4 d// 稳定性：不稳定
void ChoiceSort(int arr[], int size)
{
; H/ i6 c; @+ O, ~  l% ?# p        for (int i = 0; i < size - 1; i++)  // 比较 n - 1趟即可，最后一趟不用比较
% g1 U+ G+ X% `( U        {
& B* E2 t' S- t* m                int min = arr;
: v! \" Y) U4 v# F                int k = i;       // 记录当前比较的元素和其索引，假设当前值是最小值
- A- V" @$ ?" t                for (int j = i + 1; j < size; j++)   // 这个for循环减少了 交换次数
                {
7 ]' N' e% [: W% e9 w                        if (min > arr[j])   
' C/ p/ S$ A0 `4 F1 |+ Y                        {
                                min = arr[j];
                                k = j;
, W* @! ?2 |! E3 ~! E& Z                        }
. e. ^" S' O. @) \6 @) z2 f( `                }
                if (i != k)
                {
                        int tmp = arr;
                        arr = arr[k];
2 }4 q+ }: Y  ]. l                        arr[k] = tmp;
                }
        }

}

8 q" W' O+ R2 w1 c; ^// 插入排序
// 在普通算法中，数据越趋于有序，插入排序是最高的。
void InsertSort(int arr[], int size)
{
        for (int i = 1; i < size; i++)  // i指向无序序列中的首元素
        {
# m1 H! p* ]" G: ?) x7 _                int val = arr;  // val
                int j = i - 1;
                for (; j >= 0; j--)  // j指向了有序数列最后一个元素，每次比较实际上有序数列都多出一个位置
- [) n4 Z1 f% r* U' u! y2 n" t                {                                                // 这个for作用是找出待插入元素的位置，同时将待插入位置空出来
                        if (arr[j] <= val)
                        {
                                break;
+ e& {. p0 h9 w' M                        }
4 z+ R% }$ v9 p! x# @                        arr[j + 1] = arr[j];// j + 1 表示当前比较元素的后边一个元素，也就是要插入val的位置
                }
                arr[j + 1] = val;
- H/ g/ w2 q4 A( x& N        }
}
8 ]/ c8 p2 [. P( [! }4 `7 p7 K& m* x
7 g$ M+ p' i; s$ W6 o, Z& E) B' @  v8 Rvoid ShellSort(int arr[], int size)
{
        for (int gap = size / 2; gap > 0; gap /= 2)
        {
                for (int i = gap; i < size; i++)
3 R: l. B8 U. F8 x5 P2 g                {
3 r4 L4 i6 q, h, Y7 p4 M                        int val = arr;  // i 仍然指向无序数列首元素
" j; m9 w2 K% x) P                        int j = i - gap;     // j 仍然指向有序元素的最后一个位置
                        for (; j >= 0; j -= gap)
5 I: U4 L' v) y( I# b                        {
( i1 F# k, T5 @5 Z2 I                                if (arr[j] <= val)   // 有序数列中元素从后向前和val进行比较
0 H& [3 |9 M) {, J- O, A3 G# k                                {
3 f( a$ ?2 b! {! ]9 w) _; j                                        break;
                                }
                                arr[j + gap] = arr[j];
                        }
9 j. n- b& D  Q, X4 q8 z                        arr[j + gap] = val;
3 W, U, r3 T. M! k                }
2 Q( P- M" ^7 U7 Q2 s; w! H, K        }
0 E% o! q! ^* P4 H! i/ T
9 q( {( w7 Z/ D" [}


1 o' s$ \* R* g& k. D8 o// 四种算法比较
" ?' G( N9 K3 \: d$ k4 {$ Kint main()
{
        const int CONNT = 80000;
        int *arr1 = new int[CONNT];
! n1 A5 {8 n+ c) L" n        int *arr2 = new int[CONNT];
        int *arr3 = new int[CONNT];
0 r+ Y* B( _# ~/ Z2 j* `! @, Y2 T        int *arr4 = new int[CONNT];

        srand(time(0));
) n+ ~# X4 B8 Q$ j  _, K0 [
3 p2 U- Y, i0 R        for (int i = 0; i < CONNT; i++)
& h$ M# H. Z% N( {1 k        {
                int val = rand() % CONNT;
  E% x% F7 m% l                arr1 = val;
                arr2 = val;
                arr3 = val;
* S5 F2 l5 z8 n; _  }                arr4 = val;
2 F8 U& I4 P/ g        }
( G( P# V# L: `3 p0 H% p        cout << endl;
6 t, `3 A$ u& w. L" W+ T' l! P        clock_t begin, end;
        begin = clock();
( j, N& I" _7 w7 C- v        BubbleSort(arr1, CONNT);
2 `8 W+ y& x' V% P        end = clock();
        cout << "BubbleSort1() spend" << (end - begin)*1.0 / CLOCKS_PER_SEC << "s" << endl;

# ~. ^6 v7 i% _2 P        begin = clock();
! }4 Z, b$ @6 I8 Z' j        ChoiceSort(arr2, CONNT);
        end = clock();
        cout << "ChoiceSort() spend" << (end - begin)*1.0 / CLOCKS_PER_SEC << "s" << endl;
# A. P0 H2 R+ v# E4 C
: g' f+ q+ z3 X8 E# y$ q        begin = clock();
        InsertSort(arr3, CONNT);
& r+ M( W- e0 J$ O        end = clock();
9 F) b5 Q4 O" i: c* @        cout << "InsertSort() spend" << (end - begin)*1.0 / CLOCKS_PER_SEC << "s" << endl;
) p( M; }5 o- T9 s3 u
" B4 C3 n9 @* f. s2 Z
        begin = clock();
        ShellSort(arr4, CONNT);
1 u- m: L0 k6 c+ J1 A. C5 O* m        end = clock();
1 L3 |- N2 E$ p1 \6 ^        cout << "ShellSort() spend" << (end - begin)*1.0 / CLOCKS_PER_SEC << "s" << endl;

3 J2 Q, B" V9 H/ ?: q        system("pause");
        return 0;
}
1
2
3
4
5
7 C: {. }% L4 Y8 [8 k$ a: r2 Y0 o6
& {; V# y. [- m# q4 U: q7
8
! @: \; R5 L! p, i2 H4 b' q9
10
" k0 ~, \' t7 Z' \) U% f: y8 @9 ?2 ?11
12
3 H+ f$ b! b4 q1 B1 H: ]+ `2 l13
0 n  x) J. H# A& M" q% \# c- s4 W14
15
/ f+ b! t% v" w! J" f! Z0 ^16
17
18
" N% u* b9 p7 G$ D! p19
20
21
2 I0 }$ l; G3 {0 S22
23
: E+ E: `. {3 ~' A$ Q9 v5 {3 y24
! R) j2 g8 u+ a8 L8 J: |: ?25
9 V: Z" P0 w, B: X26
27
28
29
30
31
. p" u* o/ L# C* y7 ^% O32
% Y! f# I' D0 X  b5 V* Y& Q33
34
" g6 d9 y' v( I% |1 C/ M& M35
36
4 V4 |2 Q5 a% h; J37
! C' W3 s$ ?2 p38
39
40
* S; @! F7 D. Q6 K3 ]  a6 Y% `41
- ?9 ~& m2 p. Q* \8 e! `" c, g42
& z2 I$ k$ p. m$ `! p# J' G43
5 E3 }+ n: h1 ~8 `* v44
$ k# k3 o* M4 }1 I* d45
. ]/ e9 e' I6 F5 D: ~2 t, g46
" o& Y1 I- \" @$ j47
48
. n8 i  w# o5 x8 V$ L) V- M" s49
% Q& l! {9 Q9 W6 a( C50
8 A3 J" q! O. N  O51
52
53
54
& L9 o% `" _1 ~55
56
: ^) @5 ~( c* W% d57
  M3 D9 K+ r% a9 c- P; T58
59
60
61
62
6 C& I' n9 W3 b: l) }. w' I% k, U63
64
: ?6 _0 D. C& ^0 [/ @/ y65
( I4 Y3 X6 _3 U' }66
67
68
3 }; A+ U+ {6 N3 Q69
+ s0 w: J( k: y$ n/ P7 t7 F0 k. P70
1 w% j1 q- u, p, E! J; ~+ w* b71
" e& Z4 V% W; |72
' _2 {% L* \/ C% H73
74
! A) g7 K' c+ }7 t75
76
! y- j0 W1 }$ p* ^, A0 y77
78
79
80
81
/ Y& d3 s% G5 @# a) C8 s. {. a/ T82
83
84
85
86
87
88
" ?" V' U" k$ H- k89
5 r* E9 a) v+ p5 e# ~8 X0 g90
91
92
93
94
95
1 v: [! z+ G( s% b( z96
97
3 \" Y" b% g; h/ W4 g- m/ G$ U9 f- o98
99
100
8 S2 c6 @3 d8 s  p" G101
102
103
; I5 r* H$ ?: Z/ M, J104
105
9 D0 z  z) l2 j9 }106
107
108
2 @* D. x2 k: q' u; t8 x/ E109
110
111
% m* G4 W. w$ O8 E# E112
3 I) P0 t$ ?. ?# W; {9 b0 \113
114
115
# Z6 d8 g- C, {* o" E! t( z2 \1 C0 ~116
; |3 L  ^: Y! G: B% W117
118
119
) G: s+ Z2 L8 J  x8 X: t3 @120
7 {* s+ f+ t1 {# c# K1 [( S$ c121
122
123
124
125
& I( \' A% Y4 A/ ~126
127
1 K" m, x. q# a! }: s# u+ v128
129
130
131
132
+ y) t4 x% E6 g! ?8 |9 r133
134
135
136
' b5 M- K6 ~/ }6 e6 e137
$ b7 y$ T3 P; D5 a, u138
, B9 E* b; D" D- U139
- ^% M' A# d% X- m140
141
/ ~; l, |7 \1 y$ e  Q0 h% T三、时间对比
冒泡排序效率最低，因为每趟都涉及到交换和比较；
+ @. Y- U" o- \选择排序效率次之，减少了交换次数，所以比冒泡排序效率高一些。
; r" U# \: s) D! x  ?1 o2 m$ P, |4 Z. E插入排序没有数据的交换，对数据进行移动，移动的效率比交换的效率高，所以时间上减少了一倍。
希尔排序效率更高，移动次数比插入排序移动次数和待比较元素都减少了，所以效率更高了。


————————————————
9 D6 q! o+ `: \( `  F版权声明：本文为CSDN博主「Mr_WangAndy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
. F+ v' }; d) ?# O) S0 q  H! i原文链接：https://blog.csdn.net/weixin_43916755/article/details/126690911


' {: s+ I9 @2 z3 |5 \0 J  u' a