排序算法（二）：快速排序_快速排序选取中间值作为轴值

快速排序的思想

快速排序的思想可以通过四句话来描述：

1. 确定中轴值pivot
2. 将大于pivot的值放到其右边
3. 将小于pivot的值放到其左边
4. 对左右子序列重复前三步，即递归
   具体的原理视频推荐:我认为讲的最好的快速排序视频

快速排序的性质

1. 平均时间复杂度：O（n*logn）
2. 最差时间复杂度：O（n^2）
3. 不稳定。即排序前两个相等的数A和B，A在B的前面，但是在排序之后可能变为B在A的前面

快速排序的代码实现——以首元素为中轴值

 public static void quickSort1(int[] arr,int left,int right){
        if (left > right){
            return;
        }
        int l = left;
        int r = right;
        int pivot = arr[left];//将首元素设为中轴值
        int temp = 0;

        while(l != r){
            while(arr[r] > pivot && l< r){
                r--;
            }

            while(arr[l] < pivot && l<r){
                l++;
            }

            temp = arr[r];
            arr[r] = arr[l];
            arr[l] = temp;
        }

        if (l == r){//如果下标相等，则可以确定新的中轴值，即可以开始下一轮的快排
            pivot = arr[l];
        }
        //向左递归
        quickSort1(arr,left,r-1);//此时左子序列的左下标仍为left，右下标为r-1
        //向右递归
        quickSort1(arr,l+1,right);//右子序列的左下标为l+1,右下标为right
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

快速排序的代码实现——以中间索引的元素为中轴值

该代码可以debug一次，即好理解。注意要防止栈溢出。

    private static void quickSort(int[] arr, int left, int right) {
        int l = left;//左下标
        int r = right;//右下标
        //pivot 中轴值
        int pivot = arr[(left + right) / 2];
        int temp = 0;//临时变量，交换时使用
        //while循环的作用是让比 pivot 小的数放到左边,比其大的数放到右边
        while (l < r){
            //在pivot的左边寻找数，直到找到大于中间值时退出while循环
            while ( arr[l] < pivot ){
                l += 1;
            }

            //在pivot的右边寻找数，直到找到小于中间值时退出while循环
            while ( arr[r] > pivot){
                r -= 1;
            }
            //如果 l>= r说明中间值左右两边的值已经是:左边小于等于pivot值
            //右边大于等于pivot值
            if ( l >= r){
                break;
            }

            //当发现右边的数小于pivot，则需要将该数与对应的左边的数进行交换
            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            //如果交换之后，发现 arr[l] = pivot，则将r前移
            if (arr[l] == pivot){
                r -= 1;
            }
            //如果交换之后，发现 arr[r] = pivot，则将l后移
            if (arr[r] == pivot){
                l += 1;
            }
        }

        //如果 l == r,必须使l++ r-- 否则会出现栈溢出
        if (l == r){
            l += 1;
            r -= 1;
        }

        //向左递归
        if (left < r){//左子序列的数的个数不为1，则继续进行递归排序，此时左子序列的左下标为left，
        //右下标为r(因为防止栈溢出，r已经左移了一位)
            quickSort(arr,left,r);
        }

        //向右递归
        if (right > l){//右子序列数的个数不为1，则继续进行递归排序
            quickSort(arr,l,right);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

分别调用以上两个方法，并且输出结果

    public static void main(String[] args) {
        int[] arr = {-9,78,0,23,-567,70,-1,900,4561,22,33};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
        quickSort1(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
1
2
3
4
5
6
7

[-567, -9, -1, 0, 22, 23, 33, 70, 78, 900, 4561]
[-567, -9, -1, 0, 22, 23, 33, 70, 78, 900, 4561]
1
2