好程式設計師Java乾貨分享5分鐘瞭解折半插入排序

好程式設計師 Java 乾貨分享 5 分鐘瞭解折半插入排序，前言： 折半插入排序（ Binary Insertion Sort ）是對直接插入排序演算法的一種改進。

插入排序思想介紹

折半插入排序與直接插入排序演算法原理相同。只是，在向已排序的資料中插入資料時，採用來折半查詢（二分查詢）。先取已經排序的序列的中間元素，與待插入的資料進行比較，如果中間元素的值大於待插入的資料，那麼待插入的資料屬於陣列的前半部分，否則屬於後半部分。依次類推，不斷縮小範圍，確定要插入的位置。

演算法說明：

待排序資料： 2 ， 1 ， 6 ， 7 ， 4

取第一個元素作為有序表，剩餘的元素作為無序表

　　    其中有序表： 2 ；無序表： 1 ， 6 ， 7 ， 4

第一次比較，從無序表中取出第一個數 1 ，與中間值 2 比較， 1<2 ， 1 插到 2 的前面，得到

　　    有序表： 1 ， 2 ；無序表： 6 ， 7 ， 4

第二次比較，從無序表中取出第一個數 6 ，與中間值 1 比較， 6>1 ，要放在 1 的後面，再與後半區（有序表： 2 ）的中間值 2 比較， 6>2 ， 6 插入到 2 的後面，得到

　　    有序表： 1 ， 2 ， 6 ；無序表： 7 ， 4

第三次比較，從無序表中取出第一個數 7 ，與中間值 2 比較， 7>2 ， 7 放在 2 後面，再與後半區（有序表： 6 ）的中間值 6 比較， 7>6 ， 7 放在 6 後面，得到

　　    有序表： 1 ， 2 ， 6 ， 7 ；無序表： 4

第四次比較，從無序表中取出第一個數 4 ，與中間值 2 比較， 4>2 ， 4 放在 2 後面，再與後半區（有序表 :6,7 ）的中間值 6 比較， 4<6 ， 4 放在 6 前面，最終得到：

　　   1 ， 2 ， 4 ， 6 ， 7

折半插入排序的程式碼實現

1.private void binaryInsertSort(int arr[]){  

2.  

3.        int low = 0;  

4.        int high = 0;  

5.        int m = 0;//  中間位置   

6.        for(int i = 1; i < arr.length; i++){  

7.            low = 0;  

8.            high = i-1;  

9.            while(low <= high){  

10.                m = (low+high)/2;  

11.                if(arr[m] > arr[i])  

12.                    high = m - 1;  

13.                else  

14.                    low = m + 1;  

15.            }  

16.            // 統一移動元素，將待排序元素插入到指定位置   

17.            temp = arr[i];  

18.            for(int j=i; j > high+1; j--){  

19.                arr[j] = arr[j-1];  

20.            }  

21.            arr[high+1] = temp;  

22.        }          

23.    }  

總結

折半插入排序相對穩定，相對於直接插入排序，減少了比較次數；但是相對直接插入排序，移動次數不變。

插入排序思想介紹

折半插入排序與直接插入排序演算法原理相同。只是，在向已排序的資料中插入資料時，採用來折半查詢（二分查詢）。先取已經排序的序列的中間元素，與待插入的資料進行比較，如果中間元素的值大於待插入的資料，那麼待插入的資料屬於陣列的前半部分，否則屬於後半部分。依次類推，不斷縮小範圍，確定要插入的位置 。

演算法說明：

待排序資料： 2 ， 1 ， 6 ， 7 ， 4

取第一個元素作為有序表，剩餘的元素作為無序表

　　    其中 有序表： 2 ；無序表： 1 ， 6 ， 7 ， 4

第一次 比較 ，從無序表中取出第一個數 1 ， 與中間值 2 比較， 1<2 ， 1 插到 2 的前面，得到

　　    有序表： 1 ， 2 ；無序表： 6 ， 7 ， 4

第二次 比較 ，從無序表中取出第一個數 6 ， 與中間值 1 比較， 6>1 ，要放在 1 的後面，再與後半區（有序表： 2 ）的中間值 2 比較， 6>2 ， 6 插入到 2 的後面，得到

　　    有序表： 1 ， 2 ， 6 ；無序表： 7 ， 4

第三次 比較 ，從無序表中取出第一個數 7 ， 與中間值 2 比較， 7>2 ， 7 放在 2 後面，再與後半區（有序表： 6 ）的中間值 6 比較， 7>6 ， 7 放在 6 後面，得到

　　    有序表： 1 ， 2 ， 6 ， 7 ；無序表： 4

第四次 比較 ，從無序表中取出第一個數 4 ， 與中間值 2 比較， 4>2 ， 4 放在 2 後面，再與後半區（有序表 :6,7 ）的中間值 6 比較， 4<6 ， 4 放在 6 前面，最終得到：

　　     1 ， 2 ， 4 ， 6 ， 7

折半插入排序的程式碼實現

1.  private   void  binaryInsertSort( int  arr[]){  

2.    

3.           int  low =  ;  

4.           int  high =  ;  

5.           int  m =  ; // 中間位置   

6.           for ( int  i =  1 ; i < arr.length; i++){  

7.              low =  ;  

8.              high = i- 1 ;  

9.               while (low <= high){  

10.                  m = (low+high)/ 2 ;  

11.                   if (arr[m] > arr[i])  

12.                      high = m -  1 ;  

13.                   else   

14.                      low = m +  1 ;  

15.              }  

16.               //統一移動元素，將待排序元素插入到指定位置   

17.              temp = arr[i];  

18.               for ( int  j=i; j > high+ 1 ; j--){  

19.                  arr[j] = arr[j- 1 ];  

20.              }  

21.              arr[high+ 1 ] = temp;  

22.          }          

23.      }  

 

 

總結

折半插入排序相對穩定，相對於直接插入排序，減少了比較次數；但是相對直接插入排序，移動次數不變。