排序（選擇、希爾、二分插入）

選擇排序法                                                                                   

第1趟，在待排序記錄r[1]~r[n]中選出最小的記錄，將它與r[1]交換；第2趟，在待排序記錄r[2]~r[n]中選出最小的記錄，將它與r[2]交換；以此類推，第i趟在待排序記錄r[i]~r[n]中選出最小的記錄，將它與r[i]交換，使有序序列不斷增長直到全部排序完畢。

初始序列：{ 49 27 65 97 76 12 38 }

第1趟：12與49交換：12 { 27 65 97 76 49 38 }

第2趟：27不動：12 27 { 65 97 76 49 38 }

第3趟：65與38交換：12 27 38 { 97 76 49 65 }

第4趟：97與49交換：12 27 38 49 { 76 97 65 }

第5趟：65與76交換：12 27 38 49 65 { 97 76 }

第6趟：97與76交換：12 27 38 49 65 76 97 完成

代碼                                                                                            

public class Sort {       
    public static void main(String[] args) {         
        int[] i = { 1, 5, 6, 12, 4, 9, 3, 23, 39, 403, 596, 87 };         
        System.out.println("結果：");        
        xuanZe(i);         
        System.out.println();     
    }       
    // 選擇排序算法     
    public static void xuanZe(int[] x) {        
        for (int i = 0; i < x.length; i++) {            
            int lowerIndex = i;             
            // 找出最小的一個索引             
            for (int j = i + 1; j < x.length; j++) {                 
                if (x[j] < x[lowerIndex]) {                     
                lowerIndex = j;                
                }            
            }             

            // 交換             
            int temp = x[i];
            x[i] = x[lowerIndex];
            x[lowerIndex] = temp;         
        }
        for (int i : x) {
            System.out.print(i + " ");
        }
    }
}  

 

時間復雜度為O(N²) 。

希爾排序                                                                                      

對於n個元素的數組，假設增量為 h：

第一趟　　：　　從第1個元素開始，每隔h取一個元素，那么最后可以得到n/h個元素，一邊取，一邊通過直接插入將這h個元素排序

第二趟　　：　　從第2個元素開始，每隔h取一個元素，跟第一趟一樣。　　

...

第h趟　　 ：　　從第h個元素開始，每隔h取一個元素，跟第一趟一樣。

（此時，整個數組還不是有序的）

然后，減少h的值，重復上面的操作，直到h減小為1，排序完成。

代碼                                                                                          

public static void sort(int[] nums) {  
        int len = nums.length / 2;  
        while (len >=1) {  
            for (int i = 0; i < len; i++) {  
                // 直接插入排序對分組進行排序  
                for (int k = i; k < nums.length-len; k +=len) {  
                    int j = k + len;  
                    int temp = nums[j];  
  
                    while (k >= 0 && nums[k] > temp) {  
                        nums[j] = nums[k];  
                        k -= len;  
                        j -= len;  
                    }  
  
                    nums[j] = temp;  
                }  
            }  
            len = len/2;  
        }  
    }

時間復雜度是O(N*lgN)。

二分插入排序                                                                               

二分查找插入排序的原理：是直接插入排序的一個變種，區別是：在有序區中查找新元素插入位置時，為了減少元素比較次數提高效率，采用二分查找算法進行插入位置的確定。

代碼                                                                                           

public class BinarySearch1 {  
    public static void main(String args[])  
    {  
        int array[]={49,38,65,97,76,13,27};  
        binarySort(array,array.length);  
        System.out.println(Arrays.toString(array));  
    }  
      
    //二分查找  
    public static int binarySearch(int array[],int low,int high,int temp)  
    {  
        int mid=0;  
        while(low<=high)  
        {  
            mid=(low+high)/2;  
            if(array[mid]<temp&&temp<=array[mid+1])  
                return (mid+1);  
            else if(array[mid]<temp)  
                low = mid + 1;  
            else  
                high = mid -1;  
        }  
        return high;  
    }  
      
    //二分排序  
    public static void binarySort(int array[],int size)  
    {  
        int i,j,k,temp;  
        for(i=1;i<size;i++)  
        {  
            temp=array[i];  
            if(array[i]<array[0])  
                k=0;  
            else  
                k = binarySearch(array,0,i,temp);  
              
            for(j=i;j>k;j--)  
            {  
                array[j]=array[j-1];  
            }  
            array[k]=temp;  
            System.out.println(Arrays.toString(array));  
        }  
    }  
}

時間復雜度為O(N²) ；空間復雜度為O(1)。

我是天王蓋地虎的分割線