二分排序java实现

Posted 2020-11-18 David Xu

1.什么是二分排序：

二分排序是指利用二分法的思想对插入排序进行改进的一种插入排序算法，不同于二叉排序，可以利用数组的特点快速定位指定索引的元素；

算法思想：二分法插入排序是在插入第i个元素时，对前面的0～i-1元素进行折半，先跟他们中间的那个元素比，如果小，则对前半再进行折半，否则对后半进行折半，直到left>right，然后再把第i个元素前1位与目标位置之间的所有元素后移，再把第i个元素放在目标位置上。

2.这是普通的插入排序java实现：

 1     public static void insertSort(int[] arr){
 2         for(int i=0;i<arr.length;i++){
 3             int j = i;
 4             int k = j-1;
 5             while(k>=0){
 6                 if(arr[k]>arr[j]){
 7                     int tmp = arr[k];
 8                     arr[k] = arr[j];
 9                     arr[j] = tmp;
10                     j--;
11                     k--;
12                 }else{
13                     break;
14                 }
15             }
16         }
17     }

3.二分排序java代码实现如下：

 1     public static void binarySort(int[] arr){
 2         for(int i=1;i<arr.length;i++){
 3             int left= 0;
 4             int right= i-1;
 5             int pivot = (left+right)/2;
 6             while(left<right){
 7                 while(left<right){
 8                     if(arr[pivot]>arr[i]){
 9                         right = pivot-1;
10                         pivot = (left+right)/2;
11                     }else{
12                         break;
13                     }
14                 }
15                 while(left<right){
16                     if(arr[pivot]<arr[i]){
17                         left = pivot+1;
18                         pivot = (left+right)/2;
19                     }else{
20                         break;
21                     }
22                 }
23             }
24             if(left>=right){
25                 if(arr[pivot]<arr[i]){
26                     pivot++;
27                 }
28                 int j = i;
29                 int k = j-1;
30                 while(k>=pivot){
31                     int tmp = arr[j];
32                     arr[j] = arr[k];
33                     arr[k] = tmp;
34                     j--;
35                     k--;
36                 }
37             }
38         }
39         
40     }

 二分排序的时间复杂度：O(n^2)，空间复杂度：O(1)