排序（选择、希尔、二分插入）

选择排序法                                                                                   

第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)。

我是天王盖地虎的分割线