快速排序(对冒泡排序的改进)

基本思想：通过一趟排序将待排序的数据分成两个部分，其中一个部分的数据要比另一部分的所有数据小，然后利用该思想，对这两个部分的数据进行快排，即递归的进行快排。空间换时间，所以速度更快。

例如：[-9,78,0,23,-567,70] 分为[-9,-567] 0 [23,78,70]；向左递归[-567,-9] 0 向右递归[23,70,78]合并得[-567,-9,0,23,70,78]

如果取消左右递归，结果为-9，-567，0，23，78，70

如果取消右递归，结果为-567，-9，0，23，78，70

如果取消左递归，结果为-9，-567，0，23，70，78

public static void quickSort(int[] arr, int left, int right)
{
	int l = left;
    int right = r;
    int pivot = arr[(left+right)/2];
    int temp = 0;
    //while循环，比pivot小得放左边，大的放右边
    while (l < r) 
    {
    	while(arr[l] < arr[pivot]) 
        {
        	l += 1;
        }
        while(arr[r] > arr[pivot])
        {
        	r -= 1;
        }
        //如果l>=r，说明pivot两边的值都已正确分布，左边都小于pivot，右边都大于pivot
        if (l >= r) 
        {
        	break;
        }
        //交换
        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)
    {
    	qucikSort(arr, left, r);
    }
    //向右递归
    if (right > l)
    {
    	quickSort(arr, l, right);
    }
}