测试：排序、数组元素划分两部分

首先写快速排序：

public int[] sortArray(int[] nums) {

    quickSort(nums,0,nums.length-1);

    return nums;

}

public void quickSort(int[] nums,int begin,int end){
    if(begin>=end) return;

    random(nums,begin,end);   //随机

    int center = partition(nums,begin,end);

    quickSort(nums,begin,center-1);
    quickSort(nums,center+1,end);
}

public void swap(int[] nums,int a,int b){
    int temp = nums[a];
    nums[a] = nums[b];
    nums[b] = temp;
}

随机函数

public void random(int[] nums, int l, int r) {
    int i =(int) ( Math.random()*(r-l+1)+l );
    swap(nums, r, i);
}

其中的核心是partition函数，即将数组划分为两部分

有两种写法，第一种头尾双指针分区算法

public int partition(int[] nums,int begin,int end){

    int left = begin;
    int right = end;

    while(left<right){
        while(left<right && nums[right]>nums[begin]){
            right--;
        }
        while(left<right && nums[left]<=nums[begin]){
            left++;
        }
        if(left<right){
            swap(nums,left,right);
        }
    }

    swap(nums,begin,left);

    return left;
}

第二种是快慢指针

public int partition(int[] nums,int begin,int end){
    int slow = begin;
    int fast = begin+1;

    while(fast<=end){
        if(nums[fast]<nums[begin]){
            slow++;
            swap(nums,slow,fast);
        }
        fast++;
    }
    swap(nums,slow,begin);
    return slow;
}

两种方法都要注意边界的问题

两种双指针算法都可用于“基于一种标准的划分区间”问题

比如这个数组元素划分为两部分