快速排序

数据结构的排序部分方法很多，今天先来扒一扒在快速排序。
简单来说，快速排序只有两步：

1. 确定主元（整个待排序列的中位数）

2. 以中位数作为分隔，左边是比中位数小的元素，右边是比中位数大的元素，两边分别递归
   | 5 2 6 3 8 7 4 1 9|
   以上面数组nums[9]为例，我们先来找他的中位数pivot。
   我们先把第一个值赋给pivot（pivot=5），再设置两个指针L，R分别指向第一个元素和最后一个元素，依次比较找出中位数。

    | **5** 2 6 3 8 7 4 1 **9**|
        L                   R
   

将nums[R]与pivot（pivot=5）对比，如果nums[R]>pivot,就将R指针左移直到找到比pivot小的元素：

      |  **5** 2 6 3 8 7 4 **1** 9|
           L                 R

当找到比pivot（pivot=5）小的元素时，将该元素赋给最左边nums[L]：

      |  **1** 2 6 3 8 7 4 **1** 9|
           L                 R

将nums[L]与pivot（pivot=5）对比，如果nums[L]<pivot,
就将L指针右移直到找到比pivot大的元素；

      |  1 2 **6** 3 8 7 4 **1** 9|
               L             R

当找到比pivot（pivot=5）大的元素时，将该元素赋给R指针指向的nums[R]：

      |  1 2 **6** 3 8 7 4 **6** 9|
               L             R

此时R指针继续左移，重复以上步骤，

      |  1 2 **4** 3 8 7 **4** 6 9|
               L           R
               
      |  1 2 4 **3** 8 7 **4** 6 9|
                 L         R
                            
      |  1 2 4 3 **8** 7 **8** 6 9|
                   L       R
                                            
      |  1 2 4 3 **8** **7** 8 6 9|
                   L     R
            
      |  1 2 4 3 **8** 7 8 6 9|
                   L（R）
  此时L=R，遍历结束，将pivot（pivot=5)赋给两个指针同时指向的元素：
   |  1 2 4 3 **5** 7 8 6 9|
               L（R）

至此，中位数5左边都是比5小的，右边都是比5大的，再对两边分别递归即可。

java代码：

public void Quick_Sort(int[] nums,int left,int right){
		if(left>=right) return ;//必须有判断语句，不然无法正常结束
		int l=left,r=right;
		int pivot=nums[left];
		while(l<r){
			while(nums[r]>pivot&&l<r) r--;
			nums[l]=nums[r];
			while(nums[l]<pivot&&l<r) l++;
			nums[r]=nums[l];
			}
		nums[l]=pivot;
		Quick_Sort(nums,left,r-1);
		Quick_Sort(nums,r+1,right);

}

为了统一函数接口，我们还需进一步包装一下：

public void QuickSort(int[] nums){
		Quick_Sort(nums,0,nums.length-1);
	}

快速排序，完结撒花~o(〃‘▽’〃)o