插入排序[数据结构]（复习）

 1    /**
 2      * 插入排序
 3      * 平均O(n^2),最好O(n),最坏O(n^2);空间复杂度O(1);稳定;简单
 4      * @author zuo
 5      *
 6      */
 7     static void insertionSort(int[] a) {
 8         int tmp;
 9         for(int i=1;i<a.length;i++){
10             for(int j=i;j>0;j--){
11                 if(a[j]<a[j-1]){
12                     tmp=a[j-1];
13                     a[j-1]=a[j];
14                     a[j]=tmp;
15                 }
16             }
17         }
18     }
19     
20     public static void main(String[] args) {
21         int array[] = {10,9,2,3,6,4,7,1,5,11,8};
22         insertionSort(array);
23         for (int i : array)
24             System.out.print(i + " ");
25     }

 1    /**
 2      * 折半插入排序 
 3      * 折半查找只是减少了比较次数，但是元素的移动次数不变。
 4      * 它的空间复杂度 O(1) ，时间复杂度O(n^2)，是一种稳定的排序算法
 5      * @param data
 6      * @author zuo
 7      */
 8     static void binaryInsertSort(int[] data) {  
 9         for(int i=1;i<data.length;i++){
10             if(data[i]<data[i-1]){
11                 int tmp=data[i];//缓存处的元素值
12                 int low=0;//记录搜索范围的左边界
13                 int high=i-1;//记录搜索范围的右边界
14                 while(low<=high){
15                     int mid=(low+high)/2;//记录中间
16                     if(data[mid]<tmp){//比较中间位置数据和处数据大小，以缩小搜索范围
17                         low=mid+1;
18                     }else{
19                         high=mid-1;
20                     }
21                 }
22                 for(int j=i;j>low;j--){
23                     data[j]=data[j-1];
24                 }
25                 data[low]=tmp;
26                 print(data);
27             }
28         }
29     }  
30     
31     public static void main(String[] args) {
32         int array[] = {10,9,2,3,6,4,7,1,5,11,8};
33         binaryInsertSort(array);
34         for (int i : array)
35             System.out.print(i + " ");
36     }