常見的排序算法詳細分析與實現

1. 冒泡排序
   • 外層循環n-1輪
   • 每輪循環都比較相鄰位置的兩個值，每輪循環比較次數都依次遞減
   • 這樣，每次循環都會把大的數移到後面
   效果如下：

   原始數據：8 1 4 9 0 3 5 2 7 6
   
   1 4 8 0 3 5 2 7 6 9 
   1 4 0 3 5 2 7 6 8 9 
   1 0 3 4 2 5 6 7 8 9 
   0 1 3 2 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 9 
   1 4 0 3 5 2 7 6 8 9 
   1 0 3 4 2 5 6 7 8 9 
   0 1 3 2 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 

2. 選擇排序
   1. 外層循環n-1輪
   2. 每次循環都和後面所有數比較，選出最小值，每輪循環比較次數也是依次遞減
   3. 最後交換開始值和最小值的位置，所以交換次數固定
   效果如下：

   原始數據：8 1 4 9 0 3 5 2 7 6
   
   0 1 4 9 8 3 5 2 7 6 
   0 1 4 9 8 3 5 2 7 6 
   0 1 2 9 8 3 5 4 7 6 
   0 1 2 3 8 9 5 4 7 6 
   0 1 2 3 4 9 5 8 7 6 
   0 1 2 3 4 5 9 8 7 6 
   0 1 2 3 4 5 6 8 7 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 0 1 4 9 8 3 5 2 7 6 
   0 1 4 9 8 3 5 2 7 6 
   0 1 2 9 8 3 5 4 7 6 
   0 1 2 3 8 9 5 4 7 6 
   0 1 2 3 4 9 5 8 7 6 
   0 1 2 3 4 5 9 8 7 6 
   0 1 2 3 4 5 6 8 7 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9 

3. 插入排序
   1. 外層循環n-1輪
   2. 每輪循環當前值與前一個值比較，如果當前值小於前一個值，前一個值後移一位，依次向前比較
   3. 直到當前值大於前一個值，插入在它後面
   效果如下：

   原始數據：8 1 4 9 0 3 5 2 7 6
   1 8 4 9 0 3 5 2 7 6 
   1 4 8 9 0 3 5 2 7 6 
   1 4 8 9 0 3 5 2 7 6 
   0 1 4 8 9 3 5 2 7 6 
   0 1 3 4 8 9 5 2 7 6 
   0 1 3 4 5 8 9 2 7 6 
   0 1 2 3 4 5 8 9 7 6 
   0 1 2 3 4 5 7 8 9 6 
   0 1 2 3 4 5 6 7 8 9
   
   1 8 4 9 0 3 5 2 7 6 
   1 4 8 9 0 3 5 2 7 6 
   1 4 8 9 0 3 5 2 7 6 
   0 1 4 8 9 3 5 2 7 6 
   0 1 3 4 8 9 5 2 7 6 
   0 1 3 4 5 8 9 2 7 6 
   0 1 2 3 4 5 8 9 7 6 
   0 1 2 3 4 5 7 8 9 6 
   0 1 2 3 4 5 6 7 8 9
   
   

4. 快速排序
   1. 採用分區遞歸的方法排序，直到所有最小分區大小爲一，遞歸返回
   2. 每輪首先選取分區的第一個值作爲基準數x，通過兩個哨兵可以確定x的位置（基準數x在正確排序中的位置），並保證x的左邊都是小於它的數，右邊都是大於它的數
   3. 首先，哨兵j從分區的最右邊向左移動，找到小於x的數，停下，把該數的放到x的位置或前面哨兵i停下的位置，然後哨兵i開始移動；
   4. 哨兵i從分區的最左邊開始想右邊移動，找到大於基準數x的數，停下，把該數放到前面哨兵j停下的位置，然後哨兵j又開始移動；
   5. 一直循環3,4步驟，知道哨兵i和哨兵j相遇，這個位置就是基準數x在正確排序中的位置，把x放在該位置，一輪循環完成；
   6. 基準數x前面的數爲一個分區，後面的數爲一個分區，分別進行遞歸調用，執行前面的步驟。
   效果如下：

   原始數據：8 1 4 9 0 3 5 2 7 6
   
   第一輪 基準數爲8
   6 1 4 9 0 3 5 2 7 6 哨兵j從6開始向左移動
   6 1 4 9 0 3 5 2 7 9 哨兵i從1開始想右移動
   6 1 4 7 0 3 5 2 7 9 
   6 1 4 7 0 3 5 2 7 9 
   6 1 4 7 0 3 5 2 7 9 
   2 1 4 7 0 3 5 2 8 9 確定8的位置
   第二輪 基準數2, 只有8左邊的分區進行排序
   2 1 4 7 0 3 5 7 8 9 確定9的位置
   2 1 4 5 0 3 5 7 8 9 
   2 1 4 5 0 3 5 7 8 9 
   2 1 4 5 0 3 5 7 8 9 
   0 1 4 5 0 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 2 5 4 3 6 7 8 9 確定2的位置
   第三輪 分區0 1 基準數0 
   0 1 2 5 4 3 6 7 8 9 確定1的位置
   0 1 2 5 4 3 6 7 8 9 確定0的位置
   第四輪 分區 5 4 3 6 7 基準數5
   0 1 2 5 4 3 6 7 8 9 
   0 1 2 3 4 3 6 7 8 9 
   0 1 2 3 4 3 6 7 8 9 
   0 1 2 3 4 3 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9  確定5的位置
   第五輪 分區3 4 基準數3
   0 1 2 3 4 5 6 7 8 9 確定4的位置
   0 1 2 3 4 5 6 7 8 9 確定3的位置
   第六輪 分區 6 7 基準數6
   0 1 2 3 4 5 6 7 8 9 確定7的位置
   0 1 2 3 4 5 6 7 8 9 確定6的位置
   0 1 2 3 4 5 6 7 8 9 
   
   6 1 4 9 0 3 5 2 7 6 哨兵j從6開始向左移動
   6 1 4 9 0 3 5 2 7 9 哨兵i從1開始想右移動
   6 1 4 7 0 3 5 2 7 9 
   6 1 4 7 0 3 5 2 7 9 
   6 1 4 7 0 3 5 2 7 9 
   2 1 4 7 0 3 5 2 8 9 確定8的位置
   第二輪 基準數2, 只有8左邊的分區進行排序
   2 1 4 7 0 3 5 7 8 9 確定9的位置
   2 1 4 5 0 3 5 7 8 9 
   2 1 4 5 0 3 5 7 8 9 
   2 1 4 5 0 3 5 7 8 9 
   0 1 4 5 0 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 4 5 4 3 6 7 8 9 
   0 1 2 5 4 3 6 7 8 9 確定2的位置
   第三輪 分區0 1 基準數0 
   0 1 2 5 4 3 6 7 8 9 確定1的位置
   0 1 2 5 4 3 6 7 8 9 確定0的位置
   第四輪 分區 5 4 3 6 7 基準數5
   0 1 2 5 4 3 6 7 8 9 
   0 1 2 3 4 3 6 7 8 9 
   0 1 2 3 4 3 6 7 8 9 
   0 1 2 3 4 3 6 7 8 9 
   0 1 2 3 4 5 6 7 8 9  確定5的位置
   第五輪 分區3 4 基準數3
   0 1 2 3 4 5 6 7 8 9 確定4的位置
   0 1 2 3 4 5 6 7 8 9 確定3的位置
   第六輪 分區 6 7 基準數6
   0 1 2 3 4 5 6 7 8 9 確定7的位置
   0 1 2 3 4 5 6 7 8 9 確定6的位置
   0 1 2 3 4 5 6 7 8 9 
   
   

 

  實現代碼：

 

 

 

package test;

import java.util.Random;

/**
 * 排序算法
 */
public class SortTest {
    static int b = 0;
    static int h = 0;

    public static void main(String[] args) {
        Random random = new Random();
        int[] nums = new int[10000];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = random.nextInt(nums.length);
        }
        printArr(nums);

        printArr(maopao(nums.clone()));

        printArr(xuanze(nums.clone()));

        printArr(charu(nums.clone()));

        printArr(quickSort(nums));
    }

    /**
     * 冒泡排序
     * 1、外層循環n-1輪
     * 2、內層循環比較相鄰的兩個值
     * 3、如果前一個大於後一個，則交換兩個值的位置
     *
     * @param nums
     * @return
     */
    public static int[] maopao(int[] nums) {
        long start = System.currentTimeMillis();
        int bj = 0;
        int jh = 0;
        for (int j = 0; j < nums.length; j++) {
            for (int i = 0; i < nums.length - j - 1; i++) {
                bj++;
                if (nums[i] > nums[i + 1]) {
                    jh++;
                    int tmp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = tmp;
                }
            }
        }
        System.out.println("冒泡排序------耗時: " + (System.currentTimeMillis() - start) + "ms, " + "比較次數: " + bj + ", 交換次數: " + jh);
        return nums;
    }

    /**
     * 選擇排序
     * 1、外層循環n-1輪
     * 2、每次循環選出最小的值
     * 3、最後交換開始值和最小值的位置，所以交換次數固定
     *
     * @param nums
     * @return
     */
    public static int[] xuanze(int[] nums) {
        long start = System.currentTimeMillis();
        int bj = 0;
        int jh = 0;
        int mix, tmp;
        for (int j = 0; j < nums.length; j++) {
            mix = j;
            for (int i = j + 1; i < nums.length; i++) {
                bj++;
                if (nums[mix] > nums[i]) {
                    mix = i;
                }
            }
            jh++;//每輪比較找出最小的數，交換一次
            tmp = nums[j];
            nums[j] = nums[mix];
            nums[mix] = tmp;
        }
        System.out.println("選擇排序------耗時: " + (System.currentTimeMillis() - start) + "ms, " + "比較次數: " + bj + ", 交換次數: " + jh);
        return nums;
    }

    /**
     * 插入排序
     * 1、外層循環n-1輪
     * 2、每輪循環當前值與前一個值比較，如果當前值小於前一個值，前一個值後移一位，依次向前比較
     * 3、直到當前值大於前一個值，插入在它後面
     *
     * @param nums
     * @return
     */
    public static int[] charu(int[] nums) {
        long start = System.currentTimeMillis();
        int bj = 0;
        int jh = 0;
        int preIndex, current = 0;
        for (int i = 1; i < nums.length; i++) {
            preIndex = i - 1;
            current = nums[i];
            while (preIndex >= 0 && nums[preIndex] > current) {//前一個值大於當前值，
                bj++;
                jh++;
                nums[preIndex + 1] = nums[preIndex];//前一個值移到當前值位置
                preIndex--;//當前值再與前前一個值比較
            }
            nums[preIndex + 1] = current;//當前值大於preIndex處的值，插入在它後面
        }
        System.out.println("插入排序------耗時: " + (System.currentTimeMillis() - start) + "ms, " + "比較次數: " + bj + ", 交換次數: " + jh);
        return nums;
    }

    /**
     * 快速排序
     *
     * @param nums
     * @return
     */
    public static int[] quickSort(int[] nums) {
        long start = System.currentTimeMillis();
        nums = kuaisu(nums, 0, nums.length - 1);
        System.out.println("快速排序------耗時: " + (System.currentTimeMillis() - start) + "ms, " + "比較次數: " + b + ", 交換次數: " + h);
        return nums;
    }

    public static int[] kuaisu(int[] nums, int l, int r) {
        if (l > r) {
            // 每次遞歸排序分區大小爲1時，返回
            return nums;
        }
        // 哨兵i向右移動，哨兵j向左移動，基準數x
        int i = l, j = r, x = nums[l];//每次都選擇第一個數爲基準數
        while (i != j) {
            while (i < j && nums[j] >= x) {
                b++;
                j--;//哨兵j從右邊向左找第一個小於x的數
            }
            nums[i] = nums[j];//把小於x的數放在基準數x的位置，或已複製到右邊的大於基準數的位置
            while (i < j && nums[i] <= x) {
                b++;
                i++;//哨兵i從左邊向右找第一個大於x的數
            }
            nums[j] = nums[i];//把大於x的數放到已複製到左邊的小於x的數的位置
            h++;
        }
        nums[i] = x;//完成一輪循環，確定了一個基準數x的位置
        kuaisu(nums, l, i - 1);
        kuaisu(nums, i + 1, r);
        return nums;
    }

    public static void printArr(int[] nums) {
        for (int i : nums) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

 

 

 

  排序10000個隨機順序數的結果：

冒泡排序------耗時: 203ms, 比較次數: 49995000, 交換次數: 25069325

選擇排序------耗時: 93ms, 比較次數: 49995000, 交換次數: 10000

插入排序------耗時: 31ms, 比較次數: 25069325, 交換次數: 25069325

快速排序------耗時: 0ms, 比較次數: 149399, 交換次數: 31226