Java版快速排序算法实现

1. 递归方式

public class JavaTest1 {

    public static void main(String[] args) {
        int[] ints = {43, 0, -1, 56, 100, -245};
        System.out.println(Arrays.toString(ints));
        quickSort(ints, 0, ints.length - 1);
        System.out.println(Arrays.toString(ints));
    }

    private static void swap(int[] arr, int aIndex, int bIndex) {
        int temp = arr[aIndex];
        arr[aIndex] = arr[bIndex];
        arr[bIndex] = temp;
    }

    public static void quickSort(int[] arr, int left, int right) {
        if (left > right) {
            return;
        }
        // 获取一个参考值的索引(这里选择数组中间位置的元素作为参考值,也可以随机选择一个)
        int mid = left + (right - left) / 2;
        // 将参考值交换到数组的最左侧
        swap(arr, left, mid);
        // 用于记录有多少个值比参考值小
        int j = left;
        // 开始处理数组, 比参考值小的  将其移动到数组的左侧
        for (int i = left + 1; i <= right; i++) {
            // 将数组值依次与数组[最左侧]的参考值进行比较
            if (arr[i] < arr[left]) {
                j++;
                // 将比参考值小的元素交换到数组的左侧来
                swap(arr, i, j);
            }
        }
        // 最后将数组最左侧的参考值交换到他最终排序好的位置去
        System.out.println("数组元素值为 " + arr[left] + " 的值最终排序好的位置是 " + j);
        swap(arr, left, j);
        // 然后将参考值左侧的数组和参考值右侧的数组继续进行上述操作
        quickSort(arr, left, j - 1);
        quickSort(arr, j + 1, right);
    }
}

2. 循环方式

public class JavaTest2 {

    public static void main(String[] args) {
        int[] ints = {43, 0, -1, 56, 100, -245};
        System.out.println(Arrays.toString(ints));
        quickSort(ints);
        System.out.println(Arrays.toString(ints));
    }

    private static void swap(int[] arr, int aIndex, int bIndex) {
        int temp = arr[aIndex];
        arr[aIndex] = arr[bIndex];
        arr[bIndex] = temp;
    }

    public static void quickSort(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        Stack st = new Stack<>();
        st.push(0);
        st.push(arr.length - 1);
        while (!st.isEmpty()) {
            // 因为栈是先进后出,先推入的是左侧的下标
            // 所以推出的时候就先是右侧的下标
            int right = st.pop();
            int left = st.pop();
            // 获取一个参考值的索引(这里选择数组中间位置的元素作为参考值,也可以随机选择一个)
            int mid = left + (right - left) / 2;
            // 将参考值交换到数组的最左侧
            swap(arr, left, mid);
            // 用于记录有多少个值比参考值小
            int j = left;
            // 开始处理数组, 比参考值小的  将其移动到数组的左侧
            for (int i = left + 1; i <= right; i++) {
                // 将数组值依次与数组[最左侧]的参考值进行比较
                if (arr[i] < arr[left]) {
                    j++;
                    // 将比参考值小的元素交换到数组的左侧来
                    swap(arr, i, j);
                }
            }
            // 最后将数组最左侧的参考值交换到他最终排序好的位置去
            swap(arr, left, j);
            // 然后将参考值左侧的数组和参考值右侧的数组继续进行上述操作
            if (left < j - 1) {
                st.push(left);
                st.push(j - 1);
            }
            if (right > j + 1) {
                st.push(j + 1);
                st.push(right);
            }
        }
    }
}

3. 运行结果

[ 43, 0, -1, 56, 100, -245 ]
[ -245, -1, 0, 43, 56, 100 ]