Java排序算法(七):折半插入排序

来源:互联网 发布:在家当淘宝客服 编辑:程序博客网 时间:2024/06/08 14:24

Java排序算法(七):折半插入排序

折半插入排序法,又称二分插入排序法,是直接插入排序法的改良版,也需要执行i-1趟插入,不同之处在于,第i趟插入,先找出第i+1个元素应该插入的的位置,假定前i个数据是已经处于有序状态。

代码实现:

[java] view plaincopyprint?
  1. package sort;  
  2.   
  3. public class BinaryInsertSortTest {  
  4.     public static int count = 0;  
  5.   
  6.     public static void main(String[] args) {  
  7.   
  8.         int[] data = new int[] { 536219487 };  
  9.         print(data);  
  10.         binaryInsertSort(data);  
  11.         print(data);  
  12.   
  13.     }  
  14.   
  15.     public static void binaryInsertSort(int[] data) {  
  16.         for (int i = 1; i < data.length; i++) {  
  17.             if (data[i] < data[i - 1]) {  
  18.                 // 缓存i处的元素值  
  19.                 int tmp = data[i];  
  20.                 // 记录搜索范围的左边界  
  21.                 int low = 0;  
  22.                 // 记录搜索范围的右边界  
  23.                 int high = i - 1;  
  24.                 while (low <= high) {  
  25.                     // 记录中间位置  
  26.                     int mid = (low + high) / 2;  
  27.                     // 比较中间位置数据和i处数据大小,以缩小搜索范围  
  28.                     if (data[mid] < tmp) {  
  29.                         low = mid + 1;  
  30.                     } else {  
  31.                         high = mid - 1;  
  32.                     }  
  33.                 }  
  34.                 //将low~i处数据整体向后移动1位  
  35.                 for (int j = i; j > low; j--) {  
  36.                     data[j] = data[j - 1];  
  37.                 }  
  38.                 data[low] = tmp;  
  39.                 print(data);  
  40.             }  
  41.         }  
  42.     }  
  43.   
  44.     public static void print(int[] data) {  
  45.         for (int i = 0; i < data.length; i++) {  
  46.             System.out.print(data[i] + "\t");  
  47.         }  
  48.         System.out.println();  
  49.     }  
  50.   
  51. }  


 

运行结果:

[java] view plaincopyprint?
  1. 5   3   6   2   1   9   4   8   7     
  2. 3   5   6   2   1   9   4   8   7     
  3. 2   3   5   6   1   9   4   8   7     
  4. 1   2   3   5   6   9   4   8   7     
  5. 1   2   3   4   5   6   9   8   7     
  6. 1   2   3   4   5   6   8   9   7     
  7. 1   2   3   4   5   6   7   8   9     
  8. 1   2   3   4   5   6   7   8   9  
0 0