内部排序方式学习2(快速排序详解)

快速排序图解

       快速排序是对冒泡排序的改进，通过一轮排序将要排序的的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据小，然后同样方法对这两部分的数据进行排序，排序过程可以使用递归进行。

       假定采取从小到大的排列方式，具体步骤思路如下图： 

        按照上图思路代码如下：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {9, 78, 0, 23, -567, 70};
        System.out.println("排列前的结果为:" + Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排列后的结果为:" + Arrays.toString(arr));
    }

    //快速排序
    public static void quickSort(int[] arr, int start, int end) {
        //基准数字
        int standard = arr[start];
        //指针 left 指向 start
        int left = start;
        int right = end;
        //当 right > left 时一直循环
        while (right > left){

            while (right > left && arr[right] >= standard){
                //当right下标的值大于等于 standard表示符合要求，right指针向左移
                right--;
            }
            //退出while循环表示right的值小于等于standard或者right = left
            //将right指向的元素赋给left指向的元素
            arr[left] = arr[right];
            while (right > left && arr[left] <= standard){
                //当left下标的值小于等于standard表示符合要求，left指针向右移
                left++;
            }
            //退出while循环表示left的值大于standard或者right = left
            //将left指向的元素赋给right指向的元素
            arr[right] = arr[left];
        }
        //left = right,standard不能丢，重新赋上
        //arr[right] = standard;
        arr[left] = standard;
    }
}

结果为： 

排列前的结果为:[9, 78, 0, 23, -567, 70]
排列后的结果为:[-567, 0, 9, 23, 78, 70]

       看结果显然还是不符合要求的，不过我们已经将小于基准数9的数字放在了它的左边，大于它的放在了右边，已经完成了上图中标蓝的过程。

        接下来的步骤和上述步骤是一致的，这不就是可以自己调用自己，套娃嘛！这时我们就想到了递归！

 完整代码

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {9, 78, 0, 23, -567, 70};
        System.out.println("排列前的结果为:" + Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排列后的结果为:" + Arrays.toString(arr));
    }

    //快速排序
    public static void quickSort(int[] arr, int start, int end) {
        //设立结束条件
        if (start < end) {
            //基准数字
            int standard = arr[start];
            //指针 left 指向 start
            int left = start;
            int right = end;
            //当 right > left 时一直循环
            while (right > left) {

                while (right > left && arr[right] >= standard) {
                    //当right下标的值大于等于 standard表示符合要求，right指针向左移
                    right--;
                }
                //退出while循环表示right的值小于等于standard或者right = left
                //将right指向的元素赋给left指向的元素
                arr[left] = arr[right];
                while (right > left && arr[left] <= standard) {
                    //当left下标的值小于standard表示符合要求，left指针向右移
                    left++;
                }
                //退出while循环表示left的值大于等于standard或者right = left
                //将left指向的元素赋给right指向的元素
                arr[right] = arr[left];
            }
            // left = right,standard不能丢，重新赋上
            //arr[right] = standard;
            arr[left] = standard;
            //处理小的数
            quickSort(arr, start, right);
            //处理大的数,处理小的数里处理了基准数，所以left + 1
            quickSort(arr, left + 1, end);
        }
    }
}

结果

排列前的结果为:[9, 78, 0, 23, -567, 70]
排列后的结果为:[-567, 0, 9, 23, 70, 78]

       完成排序 

时间复杂度

       快速排序的平均时间复杂度为O(nlog n)，并且不稳定(如果a = b，a原本在b前面，排序后b可能在a前面)。

空间复杂度

        快速排序的空间复杂度为O(log n)。

---

还在学习中，如有问题辛苦指出。