快速排序

前言

我们从数组中选择一个元素，我们把这个元素称之为中轴元素吧，然后把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。

从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素)，接着我们通过递归的方式，让中轴元素左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。

为方便理解我还准备了动图：

实现代码

package fg;

public class QuickSort{
    private static int count;

    /**
     * 快速排序
     *
     * @param num   排序的数组
     * @param left  数组的前针
     * @param right 数组后针
     */
    private static void QuickSort (int[] num, int left, int right) {
        //如果left等于right，即数组只有一个元素，直接返回
        if (left >= right) {
            return;
        }
        //设置最左边的元素为基准值(key)
        int key = num[left];
        //数组中比key小的放在左边，比key大的放在右边，key值下标为i
        int i = left;
        int j = right;
        while (i < j) {
            //j向左移，直到遇到比key小的值
            while (num[j] >= key && i < j) {
                j--;
            }
            //i向右移，直到遇到比key大的值
            while (num[i] <= key && i < j) {
                i++;
            }
            //i和j指向的元素交换(i<j情况)
            if (i < j) {
                int temp = num[i];
                num[i] = num[j];
                num[j] = temp;
            }
        }
        num[left] = num[i];
        num[i] = key;
        count++;
        QuickSort(num, left, i - 1);
        QuickSort(num, i + 1, right);
    }

    /**
     * 将一个int类型数组转化为字符串
     *
     * @param arr
     * @param flag
     * @return
     */

    //遍历一下数组而已
    private static String arrayToString (int[] arr, String flag) {
        String str = "数组为(" + flag + ")：";
        for (int a : arr) {
            str += a + "\t";
        }
        return str;
    }

    /**
     * 测试
     *
     * @param args
     */
    public static void main (String[] args) {
        int[] num = {3, 44, 38, 64, 52, 11, 64, 55, 99, 11, 18,59,8989,54,12,544,6,154,4,7,454,245,45,61,64};
        System.out.println(arrayToString(num, "未排序"));
        QuickSort(num, 0, num.length - 1);
        System.out.println(arrayToString(num, "排序"));
        System.out.println("数组个数：" + num.length);
        System.out.println("循环次数：" + count);

    }
}

输出

数组为(未排序)：3	44	38	64	52	11	64	55	99	11	18	59	8989	54	12	544	6	154	4	7	454	245	45	61	64	
数组为(排序)：3	4	6	7	11	11	12	18	38	44	45	52	54	55	59	61	64	64	64	99	154	245	454	544	8989	
数组个数：25
循环次数：18

性质：

1、时间复杂度：O(nlogn)

2、空间复杂度：O(logn)

3、非稳定排序

4、原地排序

总结

快速排序是冒泡排序的改进版，也是最好的一种内排序，在很多面试题中都会出现，也是作为程序员必须掌握的一种排序方法。因此我们掌握它是非常有必要的，希望看到本篇博客的朋友能够真正的学会它！

如果您也是大学生那就关注小黄的公众号来和小黄一起学习吧！