Java常见的排序

1、直接插入排序
概述：直接插入排序是每次将一个数插入到已经有序的列表中，从而得到新的列表也有序。本排序适合：基本有序的列表

    public static  void insertSort(int[] a){
        int temp ,j= 0;
        for(int i = 1;i<a.length;i++){
            temp = a[i];
            j = i-1;
            while(j>=0&&a[j]>temp){
                a[j+1] = a[j];
                j--;
            }
            a[j+1] = temp;
        }
    }

2、希尔排序（缩小增量排序）
概述：希尔排序是直接插入排序的改进。基本思想是将序列分割成若干个子序列，分别进行直接插入排序，当整个记录基本有序时，再进行直接插入排序。

    /*
     *希尔排序（最小增量排序） 
     * */
    public static void shellSort(int[] a){
        int d = a.length;
        int temp;
        while(true){
            d= d/2;
            for(int i=0;i<d;i++){
                for(int j=i+d;j<a.length;j=j+d){
                    //待排元素
                    temp = a[j];
                    int l = 0;
                    for(l =j-d;l>=0&&a[l]>temp;l=l-d){
                        a[l+d] = a[l];
                    }
                    a[l+d] = temp;
                }

            }
            if(d==1){
                break;
            }
        }
    }

3、 冒泡排序
概述：将第一个记录的关键字和第二个记录的关键字进行比较，如果为逆序（前一个记录的关键字大于后一个记录的关键字），则交换，以此类推，一直到第N-1个记录的关键字和第N个记录的关键字进行比较，其结果使最大关键字的记录放在最后。此过程为第一趟排序。以此类推。如果某趟没有记录交换（改进算法），则排序结束。
排序过程：
初始关键字： 49 38 65 97 76 13 27 49
第一趟排序： [38 49 65 76 13 27 49] 97
第三趟排序： [38 49 65 13 27 49 ]76 97
第三趟排序: [38 49 13 27 49] 65 76 97
第四趟排序: [38 13 27 49 ]49 65 76 97
第五趟排序: [13 27 38 ]49 49 65 76 97
第六趟排序: 13 27 38 49 49 65 76 97
代码如下：`

public static void bubbleSort(int[] a){
        int temp;
        boolean flag;
        for (int i = 0; i < a.length; i++) {
            flag = true;
            for (int j = 0; j < a.length - i - 1; j++) {
                if (a[j] > a[j + 1]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = false;
                }
            }
            if(flag == true){
                break;
            }
        }
    }

4、选择排序
概述：从第 i （0<i<n）个元素开始，每一趟中选择最小的元素与第i个元素交换。
排序过程：
初始关键字： 49 38 65 97 76 13 27 49
第一趟排序： 13 [38 65 97 76 49 27 49]
第二趟排序： 13 27 [65 97 76 49 38 49]
第三趟排序： 13 27 38 [97 76 49 65 49]
第四趟排序： 13 27 38 49 [76 97 65 49]
第五趟排序： 13 27 38 49 49 [97 65 76]
第六趟排序： 13 27 38 49 49 65 [97 76]
第七趟排序： 13 27 38 49 49 65 76 97

    public static void selectSort(int[] a ) {
        int k;
        int temp;
        for(int i =0;i<a.length;i++){
            k= i;
            for(int j = i+1;j<a.length;j++){
                if(a[k]>a[j]){
                    k = j;
                }
            }
            if(k!=i){
                temp = a[i];
                a[i] = a[k];
                a[k] = temp;
            }
        }
    }

5、快速排序
概述：选择一个元素作为基准元素，通常是第一个或者最后一个，设置两个指针，i和j,i指向第一个元素，j指向最后一个元素，从后往前，如果a[j]

    public static void quickSort(int[] a,int low,int high ){
        if(low<high){
            int middle = getMiddle(a,low,high);
            quickSort(a,0,middle-1);
            quickSort(a,middle+1,high);
        }
     }
    public static int getMiddle(int[] a,int low,int high){
        int key = a[low];
        while(low<high){
            while(low<high&&key<=a[high]){
                high--;
            }
            a[low] = a[high];
            while(low<high&&key>=a[low]){
                low++;
            }
            a[high] = a[low];
        }

        a[low] = key;
        return low;
    }