Java实现快速排序以及原理

---

快速排序

快速排序，是选取数组中的一个随机值作为参考值，使其左边的元素小于参考值，右边的元素大于参数值。
一般的情况下我们选取的是数组的中间索引所在的值作为参考值的。

循环（左边索引 < 右边索引）

sort(arr,left,right), 循环使用索引为 lt = left, rt = right;

1. 先判断左边索引所在值，小于参考值，则左边索引加1。否则停止比较。
2. 先判断右边索引所在值，大于参考值，则右边索引减1。否则停止比较。
3. 判断左边索引是否大于等于右边索引，如果是则退出循环，否则执行第4步。
4. 在到达这里左边索引所在值大于等于参考值，且右边索引所在值小于等于参考值，交互两边索引的值。
5. 为了防止数组中存在多个相同值，而出现死循环。（在第4步如果交互的值都等于参考值，则不进行第5步，则下左边索引和右边索引不变，在下次执行第4步的时候，还是一样的操作，而出现死循环）需要移动左边或右边索引。如果左边索引所在值和参考值相同，则右边索引减1。如果右边索引所在值和参考值相同，则左边索引值加1。

排序之后小于参考值的在rt的左边，大于参考值的在lt的右边

排序后的数组排序

1. 判断lt是否等于rt，已防止出现栈溢出（出现ltrt的时候，说明排序后mv在最左边或最右边，这是ltleft或lt==right 在执行sort(arr,left，rt）或sort(arr,lt,right)和进入方法sort(arr,left,right) 值是一致的）。是则lt加1，rt减1。
2. 判断left与排序后的rt比较，如果小于则执行(sort(arr,left,rt)
3. 判断right与排序后的lt比较，如果大于则执行sort(arr,lt,right);

快速排序代码实现

代码示例，以及相应位置说明

package com.study.algorithm;

import java.util.Arrays;

public class QuickSort {


    public static void main(String[] args){

        int[] arr = {-1,3,5,10,100,-20,30,50,2,3,5,7,3};
        sort(arr,0,arr.length -1);
        System.out.println(Arrays.toString(arr));

    }

    public static void sort(int[] arr, int left, int right){

        int mid = (left + right) / 2;

        int lt = left;
        int rt = right;

        int mv = arr[mid];

        int tmp = 0;
        while (lt < rt){

            while (arr[lt] < mv){
                lt++;
            }

            while (arr[rt] > mv){
                rt --;
            }
            //判断以防止数组越界
            if(lt >= rt){
                break;
            }
            //执行到这 说明左边值大于等于 mv。 且右边值小于等于 mv
            tmp = arr[lt];
            arr[lt] = arr[rt];
            arr[rt] = tmp;

            //如果不做这一步，当数组中存在多个相同执行，会出现死循环
            //如 2,2,2
            if(arr[lt] == mv){
                rt --;
            }

            if(arr[rt] == mv){
                lt ++;
            }

        }
        //lt == rt的情况是，排序后，mv值在最右边，或是在最左边。会出现栈溢出
        //  arr[]     lt,rt
        //如：3,1,2    0,2
        //   3,1,2    0,1
        //   1,3,2    0,0，  执行后续操作，就会相同数据，一直入栈操作
        if(lt == rt){
            lt ++;
            rt --;
        }

        if(left < rt){
            sort(arr,left,rt);
        }
        if(right > lt){
            sort(arr,lt,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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73