Java 八種排序算法實踐

一、八種排序算法不同數據量測試

二、測試方式代碼

三、快速排序

四、希爾排序

五、歸併排序

六、基數排序

七、插入排序

八、選擇排序

九、堆排序

十、冒泡排序

---

一、八種排序算法不同數據量測試

100條隨機數據
快速排序 不穩定 耗時: 1 ms
希爾排序 不穩定 耗時: 1 ms
歸併排序 穩定 耗時: 0 ms
基數排序 穩定 耗時: 1 ms
插入排序 穩定 耗時: 0 ms
選擇排序算法 不穩定 耗時: 1 ms
堆排序 不穩定 耗時: 1 ms
冒泡排序 穩定 耗時: 1 ms
冒泡排序Plus 穩定 耗時: 0 ms

1k條隨機數據
快速排序 不穩定 耗時: 1 ms
希爾排序 不穩定 耗時: 2 ms
歸併排序 穩定 耗時: 3 ms
基數排序 穩定 耗時: 8 ms
插入排序 穩定 耗時: 4 ms
選擇排序算法 不穩定 耗時: 7 ms
堆排序 不穩定 耗時: 10 ms
冒泡排序 穩定 耗時: 11 ms
冒泡排序Plus 穩定 耗時: 9 ms

1w條隨機數據
快速排序 不穩定 耗時: 7 ms
希爾排序 不穩定 耗時: 17 ms
歸併排序 穩定 耗時: 9 ms
基數排序 穩定 耗時: 40 ms
插入排序 穩定 耗時: 23 ms
選擇排序算法 不穩定 耗時: 93 ms
堆排序 不穩定 耗時: 183 ms
冒泡排序 穩定 耗時: 200 ms
冒泡排序Plus 穩定 耗時: 201 ms

10w條隨機數據
快速排序 不穩定 耗時: 41 ms
希爾排序 不穩定 耗時: 27 ms
歸併排序 穩定 耗時: 57 ms
基數排序 穩定 耗時: 366 ms
插入排序 穩定 耗時: 1901 ms
選擇排序算法 不穩定 耗時: 5704 ms
堆排序 不穩定 耗時: 16578 ms
冒泡排序 穩定 耗時: 21210 ms
冒泡排序Plus 穩定 耗時: 20488 ms

20w條隨機數據
快速排序 不穩定 耗時: 58 ms
希爾排序 不穩定 耗時: 65 ms
歸併排序 穩定 耗時: 64 ms
基數排序 穩定 耗時: 3157 ms
插入排序 穩定 耗時: 4442 ms
選擇排序算法 不穩定 耗時: 22142 ms
堆排序 不穩定 耗時: 67493 ms
冒泡排序 穩定 耗時: 81873 ms
冒泡排序Plus 穩定 耗時: 83514 ms

30w條隨機數據   排除先前後面三種耗時長的算法
快速排序 不穩定 耗時: 57 ms
希爾排序 不穩定 耗時: 79 ms
歸併排序 穩定 耗時: 83 ms
基數排序 穩定 耗時: 5000 ms
插入排序 穩定 耗時: 10154 ms
選擇排序算法 不穩定 耗時: 50156 ms

40w條隨機數據   排除先前後面一種耗時長的算法
快速排序 不穩定 耗時: 100 ms
希爾排序 不穩定 耗時: 162 ms
歸併排序 穩定 耗時: 128 ms
基數排序 穩定 耗時: 7173 ms
插入排序 穩定 耗時: 17932 ms

50w條隨機數據
快速排序 不穩定 耗時: 91 ms
希爾排序 不穩定 耗時: 136 ms
歸併排序 穩定 耗時: 176 ms
基數排序 穩定 耗時: 10244 ms
插入排序 穩定 耗時: 29190 ms

60w條隨機數據
快速排序 不穩定 耗時: 134 ms
希爾排序 不穩定 耗時: 183 ms
歸併排序 穩定 耗時: 150 ms
基數排序 穩定 耗時: 13585 ms
插入排序 穩定 耗時: 43520 ms

70w條隨機數據 排除先前後面一種耗時長的算法
快速排序 不穩定 耗時: 153 ms
希爾排序 不穩定 耗時: 177 ms
歸併排序 穩定 耗時: 204 ms
基數排序 穩定 耗時: 17881 ms

80w條隨機數據
快速排序 不穩定 耗時: 138 ms
希爾排序 不穩定 耗時: 222 ms
歸併排序 穩定 耗時: 195 ms
基數排序 穩定 耗時: 22211 ms


90w條隨機數據
快速排序 不穩定 耗時: 174 ms
希爾排序 不穩定 耗時: 249 ms
歸併排序 穩定 耗時: 238 ms
基數排序 穩定 耗時: 30343 ms

100w條隨機數據
快速排序 不穩定 耗時: 172 ms
希爾排序 不穩定 耗時: 310 ms
歸併排序 穩定 耗時: 259 ms
基數排序 穩定 耗時: 35890 ms

500w條隨機數據  排除先前後面一種耗時長的算法
快速排序 不穩定 耗時: 955 ms
希爾排序 不穩定 耗時: 1980 ms
歸併排序 穩定 耗時: 1260 ms

1000w條隨機數據
快速排序 不穩定 耗時: 2201 ms
希爾排序 不穩定 耗時: 2864 ms
歸併排序 穩定 耗時: 2337 ms

注：

• 經過上面的數據測試得出，快速排序、希爾排序、歸併排序三種算法在數據量大時計算性能優異
• 冒泡排序、堆排序、選擇排序三種算法在數據量大時計算性能差，但1k條以內的數據量時，計算性能良好，使用盡可能在500條以內
• 基數排序、插入排序兩種算法在數據量10W條以內的數據量時，計算性能良好 

二、測試方式代碼

 /**
     * 獲取一個打亂的數組
     *
     * @param arr
     */
    private static int[] getRandomArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new Random().nextInt(arr.length);//在每個數組元素設置以數據量長度的隨機數
        }
        return arr;
    }



   private static void testSort() {
        long s;

        int[] arr = new int[10000000];//設置數據量
        int[] a = getRandomArr(arr);
        int[] b = a.clone();
        int[] c = b.clone();
        int[] d = b.clone();
        int[] e = b.clone();
        int[] f = b.clone();
        int[] g = b.clone();
        int[] h = b.clone();
        int[] i = b.clone();


        s = Clock.systemDefaultZone().millis();//獲取計算前的時間
        QuickSort.sort(f);
        //獲取計算後的時間
        System.out.println("快速排序 不穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        ShellSort.sort(i);
        System.out.println("希爾排序 不穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        MergeSort.sort(e);
        System.out.println("歸併排序 穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        RadixSort.sort(g);
        System.out.println("基數排序 穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        InsertSort.sort(d);
        System.out.println("插入排序 穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        SelectSort.sort(h);
        System.out.println("選擇排序算法 不穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        HeapSort.sort(c);
        System.out.println("堆排序 不穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        BubbleSort.sort(a);
        System.out.println("冒泡排序 穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");

        s = Clock.systemDefaultZone().millis();
        BubbleSort.sortPlus(b);
        System.out.println("冒泡排序Plus 穩定 耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    }

三、快速排序

/**
     * 快速排序
     *
     * @param numbers 帶排序數組
     */
    public static void sort(int[] numbers) {
        Test.printArr("快速排序 前：", numbers);
        if (numbers.length > 0) {   //查看數組是否爲空
            quickSort(numbers, 0, numbers.length - 1);
        }
        Test.printArr("快速排序 後：", numbers);
    }

    /**
     * 查找出中軸（默認是最低位low）的在numbers數組排序後所在位置
     *
     * @param numbers 帶查找數組
     * @param low     開始位置
     * @param high    結束位置
     * @return 中軸所在位置
     */
    public static int getMiddle(int[] numbers, int low, int high) {
        int temp = numbers[low]; //數組的第一個作爲中軸
        while (low < high) {
            while (low < high && numbers[high] >= temp) {
                high--;
            }
            numbers[low] = numbers[high];//比中軸小的記錄移到低端
            while (low < high && numbers[low] < temp) {
                low++;
            }
            numbers[high] = numbers[low]; //比中軸大的記錄移到高端
        }
        numbers[low] = temp; //中軸記錄到尾
        return low; // 返回中軸的位置
    }

    /**
     * @param numbers 帶排序數組
     * @param low     開始位置
     * @param high    結束位置
     */
    public static void quickSort(int[] numbers, int low, int high) {
        if (low < high) {
            int middle = getMiddle(numbers, low, high); //將numbers數組進行一分爲二
            quickSort(numbers, low, middle - 1);   //對低字段表進行遞歸排序
            quickSort(numbers, middle + 1, high); //對高字段表進行遞歸排序
        }

    }

四、希爾排序

/**
     * 希爾排序
     * <p>
     * 希爾排序的原理:根據需求，如果你想要結果從大到小排列，它會首先將數組進行分組，然後將較大值移到前面，較小值
     * 移到後面，最後將整個數組進行插入排序，這樣比起一開始就用插入排序減少了數據交換和移動的次數，可以說希爾排序是加強
     * 版的插入排序
     * 拿數組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 sort(int[] data) {
        Test.printArr("希爾排序 前：", 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;
            }
        }
        Test.printArr("希爾排序 後：", data);
    }

五、歸併排序

public static void sort(int[] numbers) {
        Test.printArr("歸併排序 前：", numbers);
        mergeSort(numbers, 0, numbers.length - 1);
        Test.printArr("歸併排序 後：", numbers);
    }

    /**
     * 歸併排序
     * 簡介:將兩個（或兩個以上）有序表合併成一個新的有序表 即把待排序序列分爲若干個子序列，每個子序列是有序的。
     * 然後再把有序子序列合併爲整體有序序列
     * 時間複雜度爲O(nlogn)
     * 穩定排序方式
     *
     * @param nums 待排序數組
     * @return 輸出有序數組
     */
    public static void mergeSort(int[] nums, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            // 左邊
            mergeSort(nums, low, mid);
            // 右邊
            mergeSort(nums, mid + 1, high);
            // 左右歸併
            merge(nums, low, mid, high);
        }
    }

    /**
     * 將數組中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];
        }
    }

六、基數排序

/**
     * 基數排序  本實現方式沒有避免負數排序時報錯問題
     */
    public static void sort(int[] numbers) {
        Test.printArr("基數排序 前：", numbers);
        int max = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > max) {
                max = numbers[i];
            }
        }
        int time = 0;
        while (max > 0) {
            max /= 10;
            time++;
        }
        List<ArrayList<Integer>> queue = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < 10; i++) {
            ArrayList<Integer> queue1 = new ArrayList<Integer>();
            queue.add(queue1);
        }
        for (int i = 0; i < time; i++) {
            for (int j = 0; j < numbers.length; j++) {
                int x = numbers[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
                ArrayList<Integer> queue2 = queue.get(x);
                queue2.add(numbers[j]);
                queue.set(x, queue2);
            }
            int count = 0;
            for (int k = 0; k < 10; k++) {
                while (queue.get(k).size() > 0) {
                    ArrayList<Integer> queue3 = queue.get(k);
                    numbers[count] = queue3.get(0);
                    queue3.remove(0);
                    count++;
                }
            }
        }
        Test.printArr("基數排序 後：", numbers);
    }

七、插入排序

 /**
     * 插入排序
     * <p>
     * 從第一個元素開始，該元素可以認爲已經被排序
     * 取出下一個元素，在已經排序的元素序列中從後向前掃描
     * 如果該元素（已排序）大於新元素，將該元素移到下一位置
     * 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
     * 將新元素插入到該位置中
     * 重複步驟2
     *
     * @param numbers 待排序數組
     */
    public static void sort(int[] numbers) {
        Test.printArr("插入排序 前：", 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;
        }
        Test.printArr("插入排序 後：", numbers);
    }

八、選擇排序

 /**
     * 選擇排序算法
     * 在未排序序列中找到最小元素，存放到排序序列的起始位置
     * 再從剩餘未排序元素中繼續尋找最小元素，然後放到排序序列末尾。
     * 以此類推，直到所有元素均排序完畢。
     *
     * @param numbers
     */
    public static void sort(int[] numbers) {
        Test.printArr("選擇排序算法 前：", numbers);
        int size = numbers.length; //數組長度
        int temp = 0; //中間變量

        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;
                }
            }
            //交換兩個數
            temp = numbers[i];
            numbers[i] = numbers[k];
            numbers[k] = temp;
        }
        Test.printArr("選擇排序算法 後：", numbers);
    }

九、堆排序

/**
     * 堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。
     * 　　堆的定義下：具有n個元素的序列 （h1,h2,...,hn),當且僅當滿足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）
     * (i=1,2,...,n/2)時稱之爲堆。在這裏只討論滿足前者條件的堆。由堆的定義可以看出，堆頂元素（即第一個元素）必爲
     * 最大項（大頂堆）。完全二 叉樹可以很直觀地表示堆的結構。堆頂爲根，其它爲左子樹、右子樹。
     * 　　思想:初始時把要排序的數的序列看作是一棵順序存儲的二叉樹，調整它們的存儲序，使之成爲一個 堆，這時堆的根
     * 節點的數最大。然後將根節點與堆的最後一個節點交換。然後對前面(n-1)個數重新調整使之成爲堆。依此類推，直到只有
     * 兩個節點的堆，並對 它們作交換，最後得到有n個節點的有序序列。從算法描述來看，堆排序需要兩個過程，一是建立堆，
     * 二是堆頂與堆的最後一個元素交換位置。所以堆排序有兩個函數組成。一是建堆的滲透函數，二是反覆調用滲透函數實現排
     * 序的函數。
     */
    public static void sort(int[] a) {
        Test.printArr("堆排序 前：", a);
        int arrayLength = a.length;
        //循環建堆
        for (int i = 0; i < arrayLength - 1; i++) {
            //建堆
            buildMaxHeap(a, arrayLength - 1 - i);
            //交換堆頂和最後一個元素
            swap(a, 0, arrayLength - 1 - i);

        }
        Test.printArr("堆排序 後：", 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;
                }
            }
        }
    }

    //交換
    private static void swap(int[] data, int i, int j) {
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

十、冒泡排序

 /**
     * 冒泡排序   穩定
     *
     * @param numbers 需要排序的數組
     */
    public static void sort(int[] numbers) {
        Test.printArr("冒泡排序 前：", numbers);
        for (int x = 0; x < numbers.length - 1; x++) {
            for (int y = 0; y < numbers.length - 1 - x; y++) {
                if (numbers[y] > numbers[y + 1]) {
                    int t = numbers[y];
                    numbers[y] = numbers[y + 1];
                    numbers[y + 1] = t;
                }
            }
        }
        Test.printArr("冒泡排序 後：", numbers);
    }

    /**
     * 優化冒泡排序
     * 加入一個布爾變量,如果內循環沒有交換值,說明已經排序完成,提前終止
     * @param arr
     */
    public static void sortPlus(int[] arr){
        Test.printArr("冒泡排序Plus 前：", arr);
        if(arr != null && arr.length > 1){
            for(int i = 0; i < arr.length - 1; i++){
                // 初始化一個布爾值
                boolean flag = true;
                for(int j = 0; j < arr.length - i - 1 ; j++){
                    if(arr[j] > arr[j+1]){
                        // 調換
                        int temp;
                        temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                        // 改變flag
                        flag = false;
                    }
                }
                if(flag){
                    break;
                }
            }
        }
        Test.printArr("冒泡排序Plus 後：", arr);
    }

穩定性的意義
1、如果只是簡單的進行數字的排序，那麼穩定性將毫無意義。
2、如果排序的內容僅僅是一個複雜對象的某一個數字屬性，那麼穩定性依舊將毫無意義
3、如果要排序的內容是一個複雜對象的多個數字屬性，但是其原本的初始順序毫無意義，那麼穩定性依舊將毫無意義。
4、除非要排序的內容是一個複雜對象的多個數字屬性，且其原本的初始順序存在意義，那麼我們需要在二次排序的基礎上保持原有排序的意義，才需要使用到穩定性的算法，例如要排序的內容是一組原本按照價格高低排序的對象，如今需要按照銷量高低排序，使用穩定性算法，可以使得想同銷量的對象依舊保持着價格高低的排序展現，只有銷量不同的纔會重新排序。