桶、冒泡、快速排序

今天抽空自己写了几个基本排序算法的实现，虽然都是很简单很基础的东西，但还是挺好玩的，自己写一下当做是锻炼下自己的逻辑思维。

import java.util.Random;

public class Sort {

    private final static int arraySize = 10;

    private final static int max = 100;

    private static Integer[] randomArray = new Integer[arraySize];

    public static void main(String args[]) {
        // 生成10个0~100之内的随机整数
        System.out.println("原始数据：");
        for (int i = 0; i < arraySize; i++) {
            Random random = new Random();
            randomArray[i] = random.nextInt(max);
            System.out.print(randomArray[i] + " ");
        }
        // 1:桶排序
        bucketSort();
        randomTheArray();
        // 2:冒泡排序
        bubbleSort();
        randomTheArray();
        // 3:快速排序
        quickSort();
        randomTheArray();
    }

    // 重新打乱顺序
    private static void randomTheArray() {
        Random random = new Random();
        for (int i = 0; i < arraySize; i++) {
            Integer c = randomArray[i];
            int randomIndex = random.nextInt(arraySize - 1);
            randomArray[i] = randomArray[randomIndex];
            randomArray[randomIndex] = c;
        }
    }

    // 桶排序，容易理解，速度快，时间复杂度是 O(N+M)
    // 浪费空间（随机数范围多大，桶的数目就得多大）
    // 无法对小数进行排序
    // 严格来讲桶排序算不上排序算法
    private static void bucketSort() {
        Integer[] numArray = new Integer[max + 1];
        // 数组初始化，每个值置为0
        for (int i = 0; i <= max; i++) {
            numArray[i] = 0;
        }
        for (Integer num : randomArray) {
            // numArray[num]++表示第num个桶里的数目多了一个
            numArray[num]++;
        }
        System.out.print("\n\n");
        System.out.println("桶排序后数据：");
        for (int i = 0; i <= max; i++) {
            for (int j = 0; j < numArray[i]; j++) {
                System.out.print(i + " ");
            }
        }
    }

    // 冒泡排序，时间复杂度是 O(N2)。太慢！
    // 正如 Donald E.Knuth （1974年图灵奖获得者）说：
    // “冒泡排序除了它迷人的名字和导致了某些有趣的理论问题这一事实之外，似乎没有什么值得推荐的。”
    private static void bubbleSort() {
        // arraySize-1 表示总共需要移动的数字，因为到最后必有一个数不用动
        for (int i = 0; i < arraySize - 1; i++) {
            // 如果左边的大于右边的，则调换位置，arraySize-i表示第i个数字需要比较的次数
            for (int j = 0; j < arraySize - i - 1; j++) {
                if (randomArray[j] > randomArray[j + 1]) {
                    Integer c = randomArray[j];
                    randomArray[j] = randomArray[j + 1];
                    randomArray[j + 1] = c;
                }
            }
        }
        System.out.print("\n\n");
        System.out.println("冒泡排序后数据：");
        for (int i = 0; i < arraySize; i++) {
            System.out.print(randomArray[i] + " ");
        }
    }

    // 快速排序，时间复杂度是 O(NlogN)
    // 较难理解，但是效率比冒泡排序高
    private static void quickSort() {
        quickSort(0, arraySize - 1);
        System.out.print("\n\n");
        System.out.println("快速排序后数据：");
        for (int i = 0; i < arraySize; i++) {
            System.out.print(randomArray[i] + " ");
        }
    }

    private static void quickSort(int left, int right) {
        if (left > right)
            return;
        int x;
        int i = left;
        int j = right;
        int temp = randomArray[left]; // 作为基准数
        while (i != j) {
            // 先从右边开始找，顺序不能错
            while (randomArray[j] >= temp && i < j)
                j--;
            while (randomArray[i] <= temp && i < j)
                i++;
            if (i < j) {
                x = randomArray[i];
                randomArray[i] = randomArray[j];
                randomArray[j] = x;
            }
        }
        // 基准数归位，然后递归处理左边的和右边的
        randomArray[left] = randomArray[i];
        randomArray[i] = temp;
        quickSort(left, i - 1);
        quickSort(i + 1, right);
    }
}