java的幾種經典排序算法

 排序算法大體有直接插入排序、折半插入排序、Shell排序、歸併排序、直接選擇排序、堆排序、冒泡排序、快速排序、桶式排序、基數排序等這些種，各個算法都有其優異性，你們不妨本身看看。下面貼上每一個算法的簡單講解和實現：

        1.直接選擇排序（DirectSelectSort）：其關鍵就是對n個數據要進行n-1趟比較，每趟比較的目的就是選擇出本趟比較中最小的數據，並將選擇出的數據放在本趟中的第一位。實現以下：     

<span style="font-size:18px;">public class DirectSelectSort {

    //排序方法
    public static void directSelectSort(int[] data){
        int minData = 0;
        int index = 0;
        //進行n-1趟比較
        for(int i=0; i<data.length-1; i++){
            minData = data[i];
            index = i;
            for(int j=i+1; j<data.length; j++){
                if(minData > data[j]){
                    minData = data[j];
                    index = j;
                }
            }
            //一趟比較完後，交換一次
            data[index] = data[i];
            data[i] = minData;
        }
    }

    public static void main(String args[]){
        int data[] = {22,34,12,32,50,67,43,32};
        System.out.print("排序前：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
        System.out.println();
        directSelectSort(data);
        System.out.print("排序後：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
    }

}</span>

            2.堆排序（HeapSort）:先說下堆的概念，假設有n個數據元素的序列k0,k1,k2,k3,...,kn-1,當且僅當知足下列關係時，能夠將這組數據稱爲小頂堆，即ki <= k2i+1且 ki<= k2i+2(其中i=0,2,4,...,(n-1)/2);或者，知足以下關係成爲大頂堆，即ki >= k2i+1且 ki >= k2i+2(其中i=0,2,...,(n-1)/2)。若是將堆排成一棵徹底二叉樹，則小頂堆的特色是：樹中全部節點的值都小於其左右節點的值，且根節點的值最小；而大頂堆相反。堆排序的關鍵在於：1.建堆（大頂堆或小頂堆）2.拿堆的根節點和最後一個節點交換。

<span style="font-size:18px;">public class HeapSort{

    public static void heapSort(int[] data){
        //循環建堆
        for(int i=0; i<data.length-1; i++){
            buildMaxHeap(data, data.length-1-i);
            //交換棧頂和最後一個元素
            swap(data, 0, data.length-1-i);
        }
    }

    public static void buildMaxHeap(int[] data, int lastIndex){
        //從最後一個節點的父節點開始
        for(int i=(lastIndex-1)/2; i>=0; i--){
            //保存當前正在判斷的節點
            int k = i;
            //若是當前k節點的子節點存在
            while(k*2+1 <= lastIndex){
                int biggerIndex = 2*k+1;
                if(biggerIndex < lastIndex){
                    if(data[biggerIndex] < data[biggerIndex+1]){
                        biggerIndex++;
                    }
                }
                if(data[k] < data[biggerIndex]){
                    //交換
                    swap(data, k, biggerIndex);
                    k = biggerIndex;
                }else{
                    break;
                }
            }
        }
    }

    public static void swap(int[] data, int i, int j){
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    public static void main(String[] args){
        int data[] = {22,34,12,32,50,67,43,32};
        System.out.print("排序前：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
        System.out.println();
        heapSort(data);
        System.out.print("排序後：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
    }
}</span>

          3. 冒泡排序（BubbleSort）:冒泡排序是最簡單的排序算法之一，實現起來也比較簡單，其原理就是進行n-1趟比較並交換，小數往上冒，大數往下沉，通過n-1趟以後造成了有序的數列。

<span style="font-size:18px;">public class BubbleSort {

    public static void bubbleSort(int[] data){
        for(int i=0; i<data.length-1; i++){
            for(int j=0; j<data.length-i-1; j++){
                if(data[j] > data[j+1]){
                    int temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                }
            }
        }
    }

    public static void main(String[] args){
        int data[] = {22,34,12,32,50,67,43,32};
        System.out.print("排序前：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
        System.out.println();
        bubbleSort(data);
        System.out.print("排序後：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
    }

}
</span>

            4.快速排序（QuickSort）: 快速排序死對 冒泡排序的一種改進，基本思想是：經過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的全部數據都比另一部分的全部數據都要小，而後再按此方法對這兩部分數據分別進行快速排序，整個排序過程能夠遞歸進行，以此達到整個數據變成有序序列。

<span style="font-size:18px;">public class QuickSort {

    public static void quickSort(int[] data, int start, int end){

        if(start < end){
            //以第一個元素爲分界值
            int middleNum = data[start];
            int i = start;
            int j = end + 1;
            while(true){
                //找到大於分界值的元素的索引或者已經到了end處
                while(i<end && data[++i] <= middleNum);
                //找到小於分界值的元素的索引或者已經到了start處
                while(j>start && data[--j] >= middleNum);
                if(i < j){
                    //交換
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }else{
                    break;
                }
            }
            int temp = data[start];
            data[start] = data[j];
            data[j] = temp;
            //遞歸左子序列
            quickSort(data, start, j-1);
            //遞歸右子序列
            quickSort(data, j+1, end);
        }
    }

    public static void main(String[] args){
        int data[] = {22,34,12,32,50,67,43,32};
        System.out.print("排序前：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
        System.out.println();
        quickSort(data, 0, data.length-1);
        System.out.print("排序後：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
    }

}
</span>

                5.直接插入排序（DirectInsertSort）:直接插入排序的思路很簡單，就是依次將帶排序的數據元素按其關鍵字排序的大小插入前面的有序序列。

<span style="font-size:18px;">public class DirectInsertSort {

    public static void directInsertSort(int[] data){
        for(int i=1; i<data.length; i++){
            for(int j=0; j<i; j++){
                if(data[i] < data[j]){
                    //保存插入元素
                    int temp = 0;
                    temp = data[i];
                    //將要插入元素位置後的元素依次日後移
                    for(int m=i; m>j; m--){
                        data[m] = data[m-1];
                    }
                    //插入元素
                    data[j] = temp;
                }
            }
        }
    }

    public static void main(String[] args){
        int data[] = {22,34,12,32,50,67,43,32};
        System.out.print("排序前：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
        System.out.println();
        directInsertSort(data);
        System.out.print("排序後：");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]+" ");
        }
    }

}
</span>