算法---1.插入排序

1.1直接插入排序
类似于扑克牌，假设前面的数据都是己排好序的，当下一个数据到来时，
先扫描要插入的位置，然后把数据插入。
1.2 代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define dbmsg(fmt, args ...) printf("%s:%s[%d]: "fmt"\n", __FILE__,__FUNCTION__, __LINE__,##args)
   
4. 
   
5. int dump_arry(int* arr, int len)
   
6. {
   
7.     int i;
   
8.     for(i=0; i<len; i++)
   
9.     {
   
10.         //printf("%d=%d ", i, arr[i]);
    
11.         printf("%d ", arr[i]);
    
12.     }
    
13.     printf("\n");
    
14.     return 0;
    
15. }
    
16. //b.1顺序是不对的，先找到要插入的位置
    
17. int get_insert_position(int* arr, int end_pos, int key)
    
18. {
    
19.     int i;                  //end_pos当前要插入数据的位置
    
20.     int start_pos;          //start_pos数据要插入的位置
    
21.     //printf("end_pos=%d\n",end_pos);
    
22.     for(i=end_pos; i>=0; i--)
    
23.     {
    
24.         if(arr[i]<key)
    
25.             break;
    
26.     }
    
27. 
    
28.     start_pos = i+1;
    
29.     if(i<0)
    
30.         start_pos = 0;
    
31.     return start_pos;
    
32. }
    
33. //b.2顺序是不对的，把数据插入到这个位置处
    
34. int insert_to_position(int* arr, int start_pos, int end_pos, int key)
    
35. {
    
36.     int i; //start_pos数据要插入的位置，end_pos当前要插入数据的位置
    
37.     for(i=end_pos; i>start_pos; i--)
    
38.     {
    
39.         arr[i] = arr[i-1];
    
40.     }
    
41.     arr[start_pos] = key; 
    
42.     return 0;
    
43. }
    
44. 
    
45. //按从小到大进行插入排序
    
46. int insert_sort(int* arr, int len)
    
47. {
    
48.     int i;
    
49.     int key;
    
50.     int pos;
    
51.     for(i=1; i<len; i++)
    
52.     {
    
53.         dump_arry(arr, len);
    
54.         if(arr[i] >= arr[i-1])                  //a.顺序是对的，直接跳过
    
55.             continue;
    
56.         key = arr[i];
    
57.         pos = get_insert_position(arr, i-1, key);   //b.1顺序是不对的，先找到要插入的位置
    
58.         insert_to_position(arr, pos, i, key);       //b.2顺序是不对的，把数据插入到这个位置处
    
59.     }
    
60.     return 0;
    
61. }
    
62. 
    
63. int main ( int argc, char *argv[] )
    
64. {
    
65.     //int arr[] = {49, 38, 65, 97, 76, 13, 27, 49};
    
66.     //int arr[] = {49, 38, 65, 97, 76, 13, 27, 49, 55, 4};
    
67.     int arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    
68.     int len = sizeof(arr)/sizeof(int);
    
69.     dbmsg("len=%d", len);
    
70.     insert_sort(arr, len);  //按从小到大进行插入排序
    
71.     dump_arry(arr, len);
    
72.     return EXIT_SUCCESS;
    
73. }

1.3 运行结果
49  38  65  97  76  13  27  49     -->原始数据 
38  49  65  97  76  13  27  49     -->插入38后,38<49,只需将38与49交换即可
38  49  65  97  76  13  27  49     -->插入65后，不需要移动数据
38  49  65  97  76  13  27  49     -->插入97后  
38  49  65  76  97  13  27  49     -->插入76后,76<97,只需将76与97交换即可  
13  38  49  65  76  97  27  49     -->插入13后,插入13移动的数据比较多  
13  27  38  49  65  76  97  49     -->插入27后 
13  27  38  49  49  65  76  97     -->插入49后
1.4 性能分析
O(n2) 

来源：CSDN

作者：wangcong02345

链接：https://blog.csdn.net/wangcong02345/article/details/53411492