冒泡，快速，选择排序的Java实现

冒泡,快速,选择排序 的Java实现

package chapter1;public class CheckExistDemo {    public static void main(String[] args) {        /* 新建一个数组 */        int[] testArray = { 12, 35, 99, 18, 76 };        CheckExistDemo.selectionSort(testArray);        //CheckExistDemo.bubbleSort(testArray);        //CheckExistDemo.quickSort(testArray, 1, testArray.length - 1);        System.out.print("排序的结果: ");        for (int i = 0; i < testArray.length; i++) {            if (i < testArray.length - 1) {                System.out.print(testArray[i] + ", ");            } else {                System.out.print(testArray[i]);            }        }        System.out.println();    }    /**     * Bubble sort: Time complexity is O(n^2). This one is not recommended.     * 冒泡排序：时间复杂度是O（n = 2）。这个是不推荐的。     */    public static void bubbleSort(int[] array) {        int dwTemp = 0;        // loop the whole array        for (int i = 0; i < array.length; i++) {            /*             * for each loop, if the first value is greater than the second             * value, then, swap those two values.             * 对于每个循环，如果第一个值大于第二个值，那么，交换这两个值。             */            for (int j = 0; j < array.length - 1; j++) {                if (array[j] > array[j + 1]) {                    dwTemp = array[j];                    array[j] = array[j + 1];                    array[j + 1] = dwTemp;                }            }        }    }    /**     * Quick Sort: it is suitable for sorting big data volume. The     * divide-conquer strategy is used in quicksort. Three steps: 1. Choose a     * pivot value: we take the value of the middle element as pivot value,     * which is in range of sorted values, even if it doesn't present in the     * array. 2. Partition: left to left, right to right. 3. Sort both parts:     * recursively. Time complexity is: the least one is O(N^2), and the average     * is O(nlgn) Two guards, right guard moves first, only if it detects the     * smaller one and stop. Then, left guard starts to move. If it detects     * greater one, then stop. Swap two values. recursively, detect all the     * values. Why does it work? On the partition step, algorithm divides the     * array into two parts and every element a from the left part is less or     * equal than every b from the right part. After completion of the recursion     * calls, both of the parts become sorted.     *      * Complexity analysis:Average complexity is O(nlgn), but the worst case is     * O(n^2).     *      * 快速排序：适合排序大数据量。 快速排序用分而治之的手段。三个步骤：     * 1.选择一个中间值：我们将中间元素的值作为转换值，在排序值的范围内，即使它不存在于数组中。 2.分区：从左到右，从右到右。 3.排序两部分:递归。     * 时间复杂度是：至少一个是O（N ^ 2），平均值是O（nlgn） 两个卫士，右卫兵首先移动，只有当它检测到较小的一个并且停止时。     * 然后，左卫兵开始移动。 如果检测到较大的一个，则停止。 交换两个值。 递归地检测所有的值。 为什么它工作？     * 在分区步骤中，算法将阵列分为两部分，从左侧部分的每个元素a小于或等于右侧每个b。 递归调用完成后，这两个部分都将被排序。     * 复杂度分析：平均复杂度为O（nlgn），但最差的情况是O（n ^ 2）。     */    public static void quickSort(int[] array, int low, int high) {        int index = CheckExistDemo.partition(array, low, high);        if (low < index - 1) {            quickSort(array, low, index - 1);        }        if (index < high) {            quickSort(array, index, high);        }    }    /**     * 快速排序函数     *      * @param array     * @param low     * @param high     * @return     */    public static int partition(int[] array, int low, int high) {        int dwLeftGuard = low;        int dwRightGuard = high;        int dwTemp = 0;        int dwKey = array[(low + high) / 2];        while (dwLeftGuard <= dwRightGuard) {            while (array[dwLeftGuard] < dwKey)                dwLeftGuard++;            while (array[dwRightGuard] > dwKey)                dwRightGuard--;            if (dwLeftGuard <= dwRightGuard) {                dwTemp = array[dwLeftGuard];                array[dwLeftGuard] = array[dwRightGuard];                array[dwRightGuard] = dwTemp;                dwLeftGuard++;                dwRightGuard--;            }        }        return dwLeftGuard;    }    /**     * Selection sort: Find the smallest element using a linear scan; Then, find     * the second smallest element, and move it to the front. Again, doing     * linear scan. Time complexity is O(n^2) 选择排序： 使用线性扫描找到最小的元素；     * 然后，找到第二个最小的元素，并移动到前面。 再次，做线性扫描。 时间复杂度是O（n = 2）     */    public static void selectionSort(int[] array) {        for (int i = 0; i < array.length; i++) {            for (int j = i + 1; j < array.length; j++) {                /* 碰上比前面一个数小的就交换 */                if (array[i] > array[j]) {                    int dwTemp = array[j];                    array[j] = array[i];                    array[i] = dwTemp;                }            }        }    }}