排序算法彙總

 public class QuickDemo {    public static void main(String[] args) {        int[] arr = {5, 2, 4, 9, 7, 564, 123, 643, 8, 64, 8, 75, 6, 7968, 4648, 46};//        sort(arr, 0, arr.length - 1);    }    /**     * 　堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。     * <p>堆的定義下：具備n個元素的序列 （h1,h2,...,hn),當且僅當知足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）     * (i=1,2,...,n/2)時稱之爲堆。在這裏只討論知足前者條件的堆。由堆的定義能夠看出，堆頂元素（即第一個元素）必爲最大項（大頂堆）。     * 徹底二 叉樹能夠很直觀地表示堆的結構。堆頂爲根，其它爲左子樹、右子樹。     * <p>思想:初始時把要排序的數的序列看做是一棵順序存儲的二叉樹，調整它們的存儲序，     * 使之成爲一個 堆，這時堆的根節點的數最大。而後將根節點與堆的最後一個節點交換。     * 而後對前面(n-1)個數從新調整使之成爲堆。依此類推，直到只有兩個節點的堆，並對 它們做交換，     * 最後獲得有n個節點的有序序列。從算法描述來看，堆排序須要兩個過程，一是創建堆，     * 二是堆頂與堆的最後一個元素交換位置。因此堆排序有兩個函數組成。一是建堆的滲透函數，二是反覆調用滲透函數實現排序的函數。     *     * @param args     */    public static void mains(String[] args) {        int[] a = {49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64};        int arrayLength = a.length;        //循環建堆        for (int i = 0; i < arrayLength - 1; i++) {            //建堆            buildMaxHeap(a, arrayLength - 1 - i);            //交換堆頂和最後一個元素            swap(a, 0, arrayLength - 1 - i);            System.out.println(Arrays.toString(a));        }    }    //對data數組從0到lastIndex建大頂堆    public static void buildMaxHeap(int[] data, int lastIndex) {        //從lastIndex處節點（最後一個節點）的父節點開始        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {            //k保存正在判斷的節點            int k = i;            //若是當前k節點的子節點存在            while (k * 2 + 1 <= lastIndex) {                //k節點的左子節點的索引                int biggerIndex = 2 * k + 1;                //若是biggerIndex小於lastIndex，即biggerIndex+1表明的k節點的右子節點存在                if (biggerIndex < lastIndex) {                    //若果右子節點的值較大                    if (data[biggerIndex] < data[biggerIndex + 1]) {                        //biggerIndex老是記錄較大子節點的索引                        biggerIndex++;                    }                }                //若是k節點的值小於其較大的子節點的值                if (data[k] < data[biggerIndex]) {                    //交換他們                    swap(data, k, biggerIndex);                    //將biggerIndex賦予k，開始while循環的下一次循環，從新保證k節點的值大於其左右子節點的值                    k = biggerIndex;                } else {                    break;                }            }        }    }    //交換    public static void swap(int[] data, int i, int j) {        int tmp = data[i];        data[i] = data[j];        data[j] = tmp;    }    /**     * 歸併排序     * 簡介:將兩個（或兩個以上）有序表合併成一個新的有序表 即把待排序序列分爲若干個子序列，     * 每一個子序列是有序的。而後再把有序子序列合併爲總體有序序列     * 時間複雜度爲O(nlogn)     * 穩定排序方式     *     * @param nums 待排序數組     * @return 輸出有序數組     */    public static int[] sortguibing(int[] nums, int low, int high) {        int mid = (low + high) / 2;        if (low < high) {            // 左邊            sort(nums, low, mid);            // 右邊            sort(nums, mid + 1, high);            // 左右歸併            merge(nums, low, mid, high);        }        return nums;    }    /**     * 將數組中low到high位置的數進行排序     *     * @param nums 待排序數組     * @param low  待排的開始位置     * @param mid  待排中間位置     * @param high 待排結束位置     */    public static void merge(int[] nums, int low, int mid, int high) {        int[] temp = new int[high - low + 1];        int i = low;// 左指針        int j = mid + 1;// 右指針        int k = 0;        // 把較小的數先移到新數組中        while (i <= mid && j <= high) {            if (nums[i] < nums[j]) {                temp[k++] = nums[i++];            } else {                temp[k++] = nums[j++];            }        }        // 把左邊剩餘的數移入數組        while (i <= mid) {            temp[k++] = nums[i++];        }        // 把右邊邊剩餘的數移入數組        while (j <= high) {            temp[k++] = nums[j++];        }        // 把新數組中的數覆蓋nums數組        for (int k2 = 0; k2 < temp.length; k2++) {            nums[k2 + low] = temp[k2];        }    }    /**     * 希爾排序的原理:根據需求，若是你想要結果從大到小排列，它會首先將數組進行分組，而後將較大值移到前面，較小值     * 移到後面，最後將整個數組進行插入排序，這樣比起一開始就用插入排序減小了數據交換和移動的次數，能夠說希爾排序是增強     * 版的插入排序     * 拿數組5, 2, 8, 9, 1, 3，4來講，數組長度爲7，當increment爲3時，數組分爲兩個序列     * 5，2，8和9，1，3，4，第一次排序，9和5比較，1和2比較，3和8比較，4和比其下標值小increment的數組值相比較     * 此例子是按照從大到小排列，因此大的會排在前面，第一次排序後數組爲9, 2, 8, 5, 1, 3，4     * 第一次後increment的值變爲3/2=1,此時對數組進行插入排序，     * 實現數組從大到小排     */    public static void shellSort(int[] data) {        int j = 0;        int temp = 0;        //每次將步長縮短爲原來的一半        for (int increment = data.length / 2; increment > 0; increment /= 2) {            for (int i = increment; i < data.length; i++) {                temp = data[i];                for (j = i; j >= increment; j -= increment) {                    if (temp > data[j - increment])//如想從小到大排只需修改這裏                    {                        data[j] = data[j - increment];                    } else {                        break;                    }                }                data[j] = temp;            }        }    }    /**     * 插入排序     * <p>     * 從第一個元素開始，該元素能夠認爲已經被排序     * 取出下一個元素，在已經排序的元素序列中從後向前掃描     * 若是該元素（已排序）大於新元素，將該元素移到下一位置     * 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置     * 將新元素插入到該位置中     * 重複步驟2     *     * @param numbers 待排序數組     */    public static void insertSort(int[] numbers) {        int size = numbers.length;        int temp = 0;        int j = 0;        for (int i = 0; i < size; i++) {            temp = numbers[i];            //假如temp比前面的值小，則將前面的值後移            for (j = i; j > 0 && temp < numbers[j - 1]; j--) {                numbers[j] = numbers[j - 1];            }            numbers[j] = temp;        }    }    /**     * 選擇排序算法     * 在未排序序列中找到最小元素，存放到排序序列的起始位置     * 再從剩餘未排序元素中繼續尋找最小元素，而後放到排序序列末尾。     * 以此類推，直到全部元素均排序完畢。     *     * @param numbers     */    public static void selectSort(int[] numbers) {        int size = numbers.length; //數組長度        for (int i = 0; i < size; i++) {            int k = i;   //待肯定的位置            //選擇出應該在第i個位置的數            for (int j = size - 1; j > i; j--) {                if (numbers[j] < numbers[k]) {                    k = j;                }            }            //交換兩個數            numbers[i] ^= numbers[k];            numbers[k] ^= numbers[i];            numbers[i] ^= numbers[k];        }    }    /**     * 快速排序的基本思想：     * 經過一趟排序將待排序記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另外一部分關鍵字小，     * 則分別對這兩部分繼續進行排序，直到整個序列有序。     * 快速排序的示例：     * （a）一趟排序的過程：     * （b）排序的全過程     * 把整個序列看作一個數組，把第零個位置看作中軸，和最後一個比，若是比它小交換，比它大不作任何處理；     * 交換了之後再和小的那端比，比它小不交換，比他大交換。這樣循環往復，一趟排序完成，左邊就是比中軸小的，     * 右邊就是比中軸大的，而後再用分治法，分別對這兩個獨立的數組進行排序。     */    public static void sort(int arr[], int low, int high) {        int l = low;        int h = high;        int k = arr[low];        while (l < h) {            // 從後往前比較            while (l < h && arr[h] >= k) { // 若是沒有比關鍵值小的，比較下一個，直到有比關鍵值小的交換位置，而後又從前日後比較                h--;// h=6            }            if (l < h) {                int temp = arr[h];                arr[h] = arr[l];                arr[l] = temp;                //進行過一次替換後，不必將替換後的兩值再次比較，因此i++直接下一位與k對比                l++;            }            // 從前日後比較            while (l < h && arr[l] <= k) { // 若是沒有比關鍵值大的，比較下一個，直到有比關鍵值大的交換位置                l++;            }            if (l < h) {                int temp = arr[h];                arr[h] = arr[l];                arr[l] = temp;                h--;            }            // 此時第一次循環比較結束，關鍵值的位置已經肯定了。左邊的值都比關鍵值小，右邊的值都比關鍵值大，可是兩邊的順序還有多是不同的，進行下面的遞歸調用        }        print(arr);        System.out.print("low =" + (l + 1) + ", high = " + (h + 1) + ", k=" + k + "\n");        // 遞歸        if (l > low)//先判斷l>low再次經行左邊排序            sort(arr, low, l - 1);// 左邊序列。第一個索引位置到關鍵值索引-1        if (h < high)//左邊依次排序執行完遞歸後，彈棧進行右邊排序            sort(arr, l + 1, high);// 右邊序列。從關鍵值索引+1到最後一個    }    // 打印數組的方法    private static void print(int[] arr) {        System.out.print("[");        for (int i = 0; i < arr.length; i++) {            if (i != (arr.length - 1)) {                System.out.print(arr[i] + ",");            } else {                System.out.print(arr[i] + "]");                System.out.println();            }        }    }    /**     * 冒泡排序     * 比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。     * 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。     * 針對全部的元素重複以上的步驟，除了最後一個。     * 持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。     *     * @param numbers 須要排序的整型數組     */    public static void bubbleSort(int[] numbers) {        int temp = 0;        int size = numbers.length;        for (int i = 0; i < size - 1; i++) {            for (int j = 0; j < size - 1 - i; j++) {                if (numbers[j] > numbers[j + 1])  //交換兩數位置                {                    temp = numbers[j];                    numbers[j] = numbers[j + 1];                    numbers[j + 1] = temp;                }            }        }    }}