【基于C的排序算法】插入排序之直接插入排序

杨利霞

【基于C的排序算法】插入排序之直接插入排序
- ^: a9 w# a* W$ h9 r
9 y8 T( L3 ~- h! G0 C7 r3 G9 U前言
* a- ^. J9 L: P, ]8 c4 c4 n本文基于C语言来分享一波笔者对于排序算法的插入排序中的直接插入排序的学习心得与经验，由于水平有限，纰漏难免，欢迎指正交流。

直接插入排序
# U* c1 a. |% V* _& M3 k​ 直接插入排序是一种简单的插入排序法，其基本思想是 ：
& Y' M3 J: q. w' W8 k. S
; V! Y! @" U0 b9 a  @​ 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为
4 I5 P$ e& y3 p- ]8 I  p1 X止，得到一个新的有序序列 。
​ 实际中我们玩扑克牌时，就用了插入排序的思想


& a  ~5 q3 ?* A2 e: e" u5 ~# y
​ 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array的排序码与
! U1 t# C! I* P9 farray[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array插入，原来位置上的元素顺序后移。
% j! p* o$ m* h: _
升序排列的示例：
' p7 ]2 [/ Q6 @

8 F+ l/ c! P# s! ^3 f
下面以升序排列为例讲解过程：

​ 原序列中可以分成两个序列，前面的是已排序的有序序列，用一个下标end标志该序列的尾，初始状态下end是0；后面的是还未排序的序列，用一个tmp变量暂存未排序序列首个元素，实际上是通过tmp = arr[end + 1] 实现的，也就是end指向的下一个元素。为什么要用变量暂存end的下一个元素呢？因为有可能涉及到元素后移，比如说，如果arr[end]要比tmp的值大，根据升序，应该把arr[end]的值后移对吧，那要是直接后移就会覆盖掉arr[end + 1]，所以在移动前要先把元素暂存到tmp中。在每一次比较后end要递减一下，向前移动。要是tmp比arr[end]要大该怎么操作呢？这时候就说明找到要插入的位置了，把tmp的值插入到arr[end + 1]即可。

( T! l5 J+ e6 {
" m3 o3 ^* r1 q/ h( c/ O
9 q* T/ n) E' x) b, t- Z  @* Z​ 可以看出，直接插入排序不可能只有一轮，像前面讲的过程就是一轮的过程，结果就是把未排序序列的首元素插入到了已排序序列中并保持原来的顺序，正如把刚摸到的一张牌按顺序插入到你的手牌中。实际上，一开始序列是全部未排序的，我们可以把第一个元素作为已排序元素，也就是说已排序序列一开始只有一个元素，end值就为0，后面的元素就全部都是未排序序列的了。
) z# j8 [( A& }, r* I
0 g4 v8 j7 B* X7 k+ H
( b, ?. C) w( f, {
​ 也就是说要将整个原序列排好序的话要让已排序序列拓展至整个原序列，也就是end要不断增加到size - 1（size是数组元素个数），end值为size - 1时结束，所以还要外套一个循环。

void InsertSort(int* arr, int sz)
{
9 u  B1 J; I0 I+ @9 ~        assert(arr);
! G4 ]% L: l' [) d# Z! E, A
1 Y7 o/ Q8 d) b6 }5 {; Q        for (int i = 0; i < sz - 1; ++i)//i的取值就是end的取值，end最多取到sz-2算有效，当它取到sz-1时就该结束循环了
        {
                //单轮排序
                int end = i;
1 ^" {, r5 `8 S) v( x                int tmp = arr[end + 1];
                while (end >= 0)//为什么要>=0呢？可不可以>0？
( h+ Q0 \3 ?4 o: ]0 `' o                {
                        //要排升序               
( ^$ N% _% m! q5 x                        if (tmp < arr[end])
                        {
* Y5 A8 V  k2 j                                arr[end + 1] = arr[end];
$ A2 a* C! I" Z6 g2 k                                --end;
. d+ ^6 a! A. D+ y1 y! j3 J                        }
                        else
                        {                               
                                break;
  v/ ^3 y5 s7 _" q; v% o                        }               
& i( S; o2 {8 h  k, y% D                }
9 L. E) g0 d6 k# ]                arr[end + 1] = tmp;
. ~, ?% D# ~" a0 L6 k! H/ L- _# v% G        }
}

- Y% `' V4 W1 {1 Y6 F1
2
3
4
5
1 k' `8 z/ q; }! y; g6
7
8
" v# q. s* h3 h! a* P" t! P8 [6 S5 g9
$ k( f1 W; ^( a5 x, p2 f9 G% F, ^. U10
11
; l, h6 o6 X8 S0 X+ Y12
1 x  N( D3 H  ]13
/ e. G- q# F0 h$ A* Y9 Z0 X& k14
15
& w  x' f  U8 C3 i. T% O. p; Q16
17
8 w6 {5 u& G* |/ u18
' {. C2 U! c9 p% W; }% O# M19
20
) N8 C: u+ x7 k+ V21
, g! N3 s# f6 t- [  J4 b22
23
  C# j  |( ?" M* s24
25
; T: \& R+ W" N​ end可以为0，因为有可能tmp的值比arr[0]还小，那就得让原来的arr[0]后移，把tmp放到arr[0]的位置。
+ \8 m5 n- }# N+ b/ y7 l, b
% W# v9 _, _' I# \# n, g. e
- ?: e1 n2 B5 E/ \# d7 `: n! n
直接插入排序的特性总结：

元素集合越接近有序，直接插入排序算法的时间效率越高，最好情况下（有序）时间复杂度为O(n)
时间复杂度：O(n2)
空间复杂度：O(1)，它是一种稳定的排序算法
稳定性：稳定
2 X; j+ B% e* ]( t1 c1 M( W* q感谢观看，你的支持就是对我最大的鼓励~
————————————————
版权声明：本文为CSDN博主「桦秋静」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
* \  T1 D. p3 \/ L) J8 i7 f原文链接：https://blog.csdn.net/weixin_61561736/article/details/126796593


! N. ^5 O0 O7 V% N) d( k