【java】快速排序算法

快速排序排序规则：

1. 从要排序的数据中取一个数为“基准数”。
2. 通过一趟排序将要排序的数据分割成独立的两部分，其中左边的数据都比“基准数”小，右边的数据都比“基准数”大。
3. 然后再按步骤2对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

排序动图：

 

 对应代码

    public static void main(String[] args) {
        int[] arr = new int[] { 32, 54, 22, 12, 87, 31 };

        System.out.println(Arrays.toString(arr));
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    static void quickSort(int[] arr) {   // 先左后右排序
        subQuickSortLow(arr, 0, arr.length - 1);
    }

    static void subQuickSortLow(int[] arr, int start, int end) {
        if (start < end) {
            int base = arr[start];
            int low = start;
            int high = end;

            while (low < high) {
                while (low < high && arr[low] <= base) {
                    low++;
                }
                while (low < high && arr[high] >= base) {
                    high--;
                }
                if (low < high) {
                    swap(arr, low, high);
                }
            }
            if (arr[low] > base) {
                for (int i = start; i < low - 1; i++) {
                    arr[i] = arr[i + 1];
                }
                arr[--low] = base;
            } else {
                swap(arr, start, low);
            }
            subQuickSortLow(arr, start, low - 1);
            subQuickSortLow(arr, low + 1, end);

        }
    }

    static void swap(int[] arr, int addr1, int addr2) {
        if (addr1 == addr2) {
            return;
        }
        arr[addr1] = arr[addr1] ^ arr[addr2];
        arr[addr2] = arr[addr1] ^ arr[addr2];
        arr[addr1] = arr[addr1] ^ arr[addr2];
    }

    public static void main(String[] args) {
        int[] arr = new int[] { 32, 54, 22, 12, 87, 31 };

        System.out.println(Arrays.toString(arr));
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    static void quickSort(int[] arr) {   // 先右后左排序
        subQuickSortHigh(arr, 0, arr.length - 1);
    }

    static void subQuickSortHigh(int[] arr, int start, int end) {
        if (start < end) {
            int base = arr[start];
            int low = start;
            int high = end;

            while (low < high) {
                while (low < high && arr[high] >= base) {
                    high--;
                }
                while (low < high && arr[low] <= base) {
                    low++;
                }
                if (low < high) {
                    swap(arr, low, high);
                }
            }
            swap(arr, start, high);
            subQuickSortHigh(arr, start, high - 1);
            subQuickSortHigh(arr, high + 1, end);
        }
    }

    static void swap(int[] arr, int addr1, int addr2) {
        if (addr1 == addr2) {
            return;
        }
        arr[addr1] = arr[addr1] ^ arr[addr2];
        arr[addr2] = arr[addr1] ^ arr[addr2];
        arr[addr1] = arr[addr1] ^ arr[addr2];
    }

两种方式都可以实现排序，区别在于，从左到右排序需要考虑low点正好是中间值点的问题。这时需要将左半部分左移一位+插入基准值。

其实从这个角度上来看，从左到右的算法较为复杂，所以直接记住先high后low的算法即可。