基础算法--排序： 之插入排序

冒泡排序两两比较指的是： 未排序的相邻元素之间的两两比较，对于已排好的元素，它不再访问。

 

       而插入排序中的比较则是： 在未排序的元素中，取出一个，将它与已排好的元素进行比较，从而确定其位置。 

                                                         是某未排元素，与诸多已排元素的逐次比较。

 

      其排序图解如下：

    

 

 

 

程序代码：

 

1） 比较一次 ， 移动一次

[cpp] view plaincopy

1.    //比较一次，移动一次  
2.   
3. void StraightInsertionSort(int *p,int n)  
4. {  
5.   
6.     int i,j,t;  
7.   
8.     for (i=1;i<n;i++)   // 0...i-1 是已排好元素   i...n-1是未排元素  
9.     {  
10.         t=p[i]; // 记录下 将要与排好序的元素 进行比较的那个 未排序元素  
11.         for (j=i-1;j>=0;j--)  
12.         {  
13.             if (t<p[j])  // 比较一次， 移动一次  
14.             {  
15.                 p[j+1]=p[j];  
16.                 p[j]=t;  
17.   
18.             }else{  
19.                 break;  //  已经将t 存放到目标位置  
20.             }  
21.         }  
22.     }  
23. }  

 

 

2） 先找到合适位置，再集体移动

[cpp] view plaincopy

1. //  先找位置 再集体移动  
2.   
3. void StraightInsertionSort(int *p,int n)  
4. {  
5.   
6.     int i,j,t;  
7.   
8.     for (i=1;i<n;i++)   // 0...i-1 是已排好元素   i...n-1是未排元素  
9.     {  
10.         t=p[i]; // 记录下 将要与排好序的元素 进行比较的那个 未排序元素  
11.   
12.         // 找t所应在的位置  
13.         for (j=i-1;j>=0;j--)  
14.         {  
15.   
16.             if (t>=p[j])  // 说明t应该放在j+1 位置上  
17.                 break;  
18.         }  
19.   
20.   
21.         for (int k=i-1;k>j;k--)  
22.         {  
23.             p[k+1]=p[k];  
24.         }  
25.   
26.         p[j+1]=t;  
27.   
28.     }  
29. }  

 

3） 对于情况2，可以用二分查找法优化程序, 如下：

 

[cpp] view plaincopy

1. void BinaryInsertionSort(int *p, int n)  
2. {  
3.   
4.     int i,j,k;  
5.   
6.     for (i=1;i<n;i++)   // 0...i-1 是已排好元素   i...n-1是未排元素  
7.     {  
8.         int t=p[i]; // 记录下 将要与排好序的元素 进行比较的那个 未排序元素  
9.   
10.         int iLeft=0;  
11.         int iRight=i-1;  
12.         int iMiddle=(iLeft+iRight)/2;  
13.   
14.         while (iLeft<=iRight)  
15.         {  
16.   
17.             if (t>p[iMiddle])  
18.             {  
19.                 iLeft=iMiddle+1;  
20.             }  
21.   
22.             if (t<p[iMiddle])  
23.             {  
24.                 iRight=iMiddle-1;  
25.             }  
26.   
27.   
28.             if (t==p[iMiddle])  
29.             {  
30.                 j=iMiddle;  // 0....j  不需移动  j+1...i-1 需要后移一位   t 应保存在第j+1位置  
31.                 break;  
32.                   
33.             }  
34.   
35.             iMiddle=(iLeft+iRight)/2;  
36.   
37.         }  
38.   
39.         if (iLeft>iRight)  
40.         {  
41.             j=iLeft-1; // 0....j  不需移动  j+1...i-1 需要后移一位   t应保存在第j+1位置  
42.   
43.         }  
44.   
45.              
46.         for (k=i-1;k>j;k--)  
47.         {  
48.             p[k+1]=p[k];  
49.         }  
50.   
51.         p[j+1]=t;  
52.     }  
53.   
54. }