Java之快速排序算法

2019独角兽企业重金招聘Python工程师标准>>>

一、快速排序算法概况

1.首先会选择第一个元素(实际一般也都会选第一个)作为比较值（称“枢轴”（pivot））

2.循环找出小于pivot的元素，将元素放在pivot的左边

3.循环找出大于pivot的元素，将元素放在pivot的右边

4.然后再对pivot左边和右边的数组进行同样的操作(递归)

二、下面贴上一段代码：

    void quickSort(int[] n) {
        if (n == null || n.length <= 0) {
            return;
        }
        quickSort(n, 0, n.length - 1);
    }

    private void quickSort(int[] n, int low, int high) {//D
        if (low >= high) {
            return;
        }
        int pivot = partition(n, low, high);// A
        quickSort(n, low, pivot - 1);// B
        quickSort(n, pivot + 1, high);// C
    }

    private int partition(int[] n, int low, int high) {
        // 1.定义比较的关键值(当前数组第一个位置的元素)
        int pivot = n[low];
        while (low < high) {
            // 2.找到第一个小于关键值得数据
            while ((low < high) && (n[high] >= pivot)) {
                high--;
            }
            // 3.找到后将这个小于关键值得数据赋值给n[low]
            n[low] = n[high];
            // 4.然后找到第一个大于关键值得数据
            while ((low < high) && (n[low] <= pivot)) {
                low++;
            }
            // 5.然后将这个大于关键值得数据赋值给n[high]
            n[high] = n[low];
        }
        // 6.循环完毕,返回pivot的位置
        n[low] = pivot;
        return low;
    }

三、分析

假如我们将传入int[] n = {20,8,10,12,6}这个数组；

1.进入D，quickSort(int[] n, int low, int high) // low = 0; high = n.length - 1

然后进入A，partition(int[] n, int low, int high) // low = 0; high = n.length - 1

2.首先提取数组的第一个元素作为pivot，第一个元素pivot当然就是20，之后也都取当前数组的第一个位置的元素作为pivot；

    int pivot = n[low];

3.判断low < high，符合进入循环体； while (low < high)

4.判断找到第一个小于pivot的值；（找到了high下标为4的元素，a[high]=6）

    while ((low < high) && (n[high] >= pivot)) {

        // 如果没有找到(对high下标进行递减操作，直到不满足low < high)

        high--;

    }

5.n[low] = n[high];

    a.如果找到了小于pivot的值，然后将值给n[low]位置，也就是将放在pivot的左边；

    b.如果没找到，对high进行递减操作，直到不满足low < high为止

    （如果没找到，high--，最后会是high==low，执行完第6步，由于不满足循环条件，退出循环），那就是对n[low]本身的值进行操作 这里找到了(此时high还是4)，就是将n[4]给了n[0]，

    此刻数组是这样的：[6,8,10,12,6]

6.判断找到第一个大于Pivot的值；（这里面没有大于20的值，所以会一直对low累加至4，low = 4）;

    // 如果找到了，表示找到了大于pivot的值，如果没有就将对low自增，直到不满足low < high

    while ((low < high) && (n[low] <= pivot)) {

        low++;

    }

low = 4，这里，我们没有找到比pivot也就是20还要大的值(low通过自增变为4，high还是4)，然后将自己赋值给自己。数组此时保持不变：[6,8,10,12,6]

7.此时，不满足low < high退出循环

8.n[low] = pivot; 将pivot值给n[4]。此时数组是这样的：[6,8,10,12,20]

9.return low; 返回pivot，也就是4。

10.这个时候进入B，然后再执行A

    quickSort(n, low, pivot - 1);

    partition(n, low, pivot - 1)

11.进入递归循环调用，步骤和上述一样。不管第一个步骤是否已经将数组排序好了，快速排序都会执行一遍，直到执行完毕。

最终数组：[6,8,10,12,20]

转载于:https://my.oschina.net/u/3425110/blog/1839536