冒泡排序 优化 和选择排序，快速排序

/**
     * 冒泡排序  蛮力法 （n<5）比其他排序快
     * 

     * 时间复杂度 n*(n-1)/2   n²/2  n   0(n²)
     * 空间复杂度    O(1)
     */
    @Test
    public void bubbleSort() {
        int[] array = {8, 4, 3, 1, 5, 2, 6, 7, 9};
        for (int j = 0; j < array.length - 1; j++) {
            boolean flag = true;
            for (int k = j + 1; k < array.length; k++) {
                if (array[j] > array[k]) {
                    int i = array[k];
                    array[k] = array[j];
                    array[j] = i;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "--");
        }
        System.out.print("\n");
    }

    /**
     * 选择排序
     * 

     * 时间复杂度  0(n²)
     * 空间复杂度    O(1)
     */
    @Test
    public void selectSort() {
        int[] array = {8, 4, 3, 1, 5, 2, 6, 7, 9};
        for (int j = 0; j < array.length - 1; j++) {
            int index = j;
            for (int k = j + 1; k < array.length; k++) {
                if (array[index] > array[k]) {
                    index = k;
                }
            }
            if (index != j) {//交换位置
                array[index] = array[index] ^ array[j];
                array[j] = array[index] ^ array[j];
                array[index] = array[index] ^ array[j];
            }
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "--");
        }
        System.out.print("\n");
    }

    /**
     * 快速排序
     * 

     * 时间复杂度O(nlogn)
     *
     * @param array 排序的数组
     * @param begin 开始的位置
     * @param end   结束的位置
     */
    private void quickSort(int[] array, int begin, int end) {
        if (end - begin <= 0) {
            return;
        }
        int x = array[begin];
        int low = begin;
        int high = end;
        //由于会从两头取数据，需要一个方向
        boolean direction = true;
        L1:
        while (low < high) {
            if (direction) {//从右往左找
                for (int i = high; i > low; i--) {
                    // 如果 右面数据小于定义的中间数，则把该数移动到 定义的中间数的位置
                    if (array[i] <= x) {
                        //移动之后 低指针右移
                        array[low++] = array[i];
                        high = i;
                        direction = !direction;
                        continue L1;
                    }
                }
                high = low;//如果上面的if从未进入，让两个指针重合
            } else {
                for (int i = low; i < high; i++) {
                    // 如果 右面数据小于定义的中间数，则把该数移动到 定义的中间数的位置
                    if (array[i] >= x) {
                        //移动之后 低指针右移
                        array[high--] = array[i];
                        low = i;
                        direction = !direction;
                        continue L1;
                    }
                }
                low = high;//如果上面的if从未进入，让两个指针重合
            }
        }
        //把最后找到的值，放入中间位置
        array[low]=x;
        //开始完成左右两边的操作(遍历)
//        quickSort(array,begin,low-1);
//        quickSort(array,low+1,end);
    }