排序算法

public class Sort {

    public static void main(String[] args) {
        int[] arr = {49, 38, 65, 97, 23, 22, 76, 1, 5, 8, 2, 0, -1, 22};

        quickSort(arr, 0, arr.length - 1);
        bubbleSort(arr);

        System.out.println("排序后:");
        for (int i : arr) {
            System.out.println(i);
        }
    }

    /*
     * 冒泡排序：
     *
     *
     * */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }


    /*
     * 快速排序：快速排序的思想是，指定一个基准元素，通过排序使基准数左边的序列都小于它，它右边的序列都大于它，然后递归排序其左右子序列
     *
     * 1. 初始化 low 指向第一个元素，high 指向最后一个元素
     * 2. 选定 low 指向的元素为基准元素
     * 3. 比较选定元素是否大于 high 指向的元素，若指定元素小于 high 指向的元素则 high 向前移，
     *      直到 low >= high 或者指定元素大于 high 指向元素
     * 4. arr[low] = arr[high];
     * 5. 比较选定元素是否大于 low 指向的元素，若指定元素大于 low 指向的元素则 low 向后移，
     *      直到 low >= high 或者指定元素小于 low 指向元素
     * 6. arr[high] = arr[low];
     * 7. 重复 3 - 6，直到 low >= high
     * 8. arr[low] = tmp; 此时，low 左边的的元素都小于基准值,low 右边的的元素都大于基准值
     * 9. 以 low 为分割点，递归遍历 low 左边和右边的序列
     * */
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int index = getIndex(arr, low, high);
            // quickSort(arr,0, index);
            quickSort(arr, low, index - 1);
            quickSort(arr, index + 1, high);
        }
    }

    public static int getIndex(int[] arr, int low, int high) {
        int tmp = arr[low];
        while (low < high) {
            while (low < high && tmp <= arr[high]) {
                high--;
            }
            arr[low] = arr[high];

            while (low < high && tmp >= arr[low]) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = tmp;
        return low;
    }
}