java实现快速排序quicksort

简述：选择一个pivot当参考，比它大的放右边，比它小的放左边。

加一些细节：

1. 有一个乱序数组：ori_array。
2. 选第一个值当pivot。
3. 数组左右各一个指针(L=0，R=length-1)。
4. R指针从右往左和pivot比大小，
   1. 如果array[R]比pivot大，则R--；
   2.  如果array[R] < pivot，则把array[R]的值放在L指针的位置，L指针开始(从前往后)移动。（在“改变位置”操作之后，要换另一个指针工作）
5. 当指针相等时L==R，在当前位置放入pivot。

我的代码：

import java.util.Arrays;

public class quicksort {
    public static void main(String[] args) {
        int pivot;
        int[] oriarray = {19, 97, 9, 17, 1, 8};
        System.out.println(Arrays.toString(oriarray));
        for(int times=0; times<oriarray.length; times++){
            pivot = oriarray[0];
            int L = 0;
            int R = oriarray.length - 1;
            while (L < R) {
                System.out.println("L:"+L);
                System.out.println("R:"+R);
                while (oriarray[R] > pivot && L < R)R--;
                if (oriarray[R] < pivot) {
                    oriarray[L] = oriarray[R]; //因为数组第一个数被存为pivot，如果操作，不会被覆盖
                    oriarray[R] = 0; // 原来的位置被空出来
                    L++; //操作相反方向
                }
                while (oriarray[L] < pivot && L < R)L++;
                if (oriarray[L] > pivot){
                    oriarray[R] = oriarray[L];
                    oriarray[L] = 0;
                    R--;
                }
                System.out.println(Arrays.toString(oriarray));
            }
                if (L == R) {
                    oriarray[L] = pivot;
                }
        }
        System.out.println(Arrays.toString(oriarray));
    }
}

分析：(转载自wudilet)

快排优点在于效率较高，执行过程中不需要额外存储空间，而且对cache比较友好。快排也有一些缺点：它是不稳定的，对于数据中大小相同的元素，他们在快排之后的相对位置可能会发生改变。

时间复杂度分析：

最好情况下的时间复杂度为 O(nlogn) ：n表示数组总长度，弱每次选中median作为pivot，则如图

，树的深度为logn

最差情况下其时间复杂度为 O(n^2)：弱每次选中max或min值作为pivot，则如图：，树的深度为n。