快速排序算法(挖坑法+左右指针法+快慢指针法）

挖坑法

挖坑法，可以理解成拆东墙补西墙。这里以数组[4,1,7,6,9,2,8,0,3,5]为例子讲解。以数据第一个元素作为枢轴（也可以是最后一个，看你喜好）。
这里我们先把作为枢轴的4抠出来单独放置，此时数组变成了
[口,1,7,6,9,2,8,0,3,5]
这时我们要从数组尾部开始往前找，找第一个比4小的数字，5比4大，j - -，这时3比4小，把3放在坑里。因为把3抠出来补坑里了，因此3原来所在的位置又变成了一个坑。
[3,1,7,6,9,2,8,0,口,5]
这时候我们要从数组头部开始往后找，找第一个比4大的数字，1比4小，i + +，这时7比4大，把7放在坑里。这时，7原来的位置又变成了坑。
[3,1,口,6,9,2,8,0,7,5]
接着从数组右边开始找比4小的数，0比4小，把0抠出来放在坑里。0原来的位置又变成了坑。
[3,1,0,6,9,2,8,口,7,5]
接着从数组左边开始找比4大的数字，6比4大，把6抠出来放在坑里。6原来的位置又变成了一个坑。
[3,1,0,口,9,2,8,6,7,5]
接着从右边开始找比4小的数字，8不比4小，j - -，这时2比4小，把2抠出来放在坑里。2原来的位置变成了坑。
[3,1,0,2,9,口,8,6,7,5]
接着从数组左边找比4大的数字，9比4大，把9放进坑里。9原来的位置变成了坑。
[3,1,0,2,口,9,8,6,7,5]
此时i==j，即游标重叠了。这时，我们将一开始取出来的枢轴4放进最后这个坑里。这就完成了第一趟快排。
[3,1,0,2,4,9,8,6,7,5]
你会发现枢轴4左边的数字都比4小，4右边的数字都比4大。
接下来[3,1,0,2]和[9,8,6,7,5]分别都采用这样的挖坑法进行排序。一直到数组只包含一个数字为止，便完成了最终的排序。

public class Test {
    static void quicksort(int s[],int left,int right){
           if(left<right){
               int temp=s[left],i=left,j=right;   
               while(i<j) {
            	 //寻找右边第一个小于基准值的下标
                   while(s[j]>=temp&&i<j)j--;
                   if(i<j) {s[i]=s[j];i++;}
                 //寻找左边第一个大于基准值的下标
                   while(s[i]<=temp&&i<j)i++;
                   if(i<j) {s[j]=s[i];j--;}         
               }
                      
               s[i]=temp;//当游标指针i和j重叠时将枢轴填入坑
               System.out.println("-----枢轴："+temp);
               quicksort(s,left,i-1);      //递归左边部分数组
               quicksort(s,i+1,right);     //递归右边部分数组
           }
       }

    public static void main(String[] args) {
        int []a= {4,1,7,6,9,2,8,0,3,5};
        quicksort(a,0,a.length-1);
        for(int i:a) {
            System.out.print(i+" ");
        }
    }
}
	         

输出：
-----枢轴：4
-----枢轴：3
-----枢轴：2
-----枢轴：0
-----枢轴：9
-----枢轴：5
-----枢轴：8
-----枢轴：7
0 1 2 3 4 5 6 7 8 9

左右指针法

思想:

1、选取一个关键字(key)作为枢轴，一般取整组记录的第一个数/最后一个为枢轴。
2、设置两个变量left = 0;right = N - 1;
3、从left一直向后走，直到找到一个大于key的值，right从后至前，直至找到一个小于key的值，然后交换这两个数。
4、重复第三步，一直往后找，直到left和right相遇，这时将key放置left的位置即可。

这里还是以[4,1,7,6,9,2,8,0,3,5]为例做解释。这里以第一个元素4作为枢轴。right向前找比4小的数，此时3比4小，left向后找比4大的数，此时7比4大，交换3和7；
[4,1,3,6,9,2,8,0,7,5]
right向前找比4小的数，此时0比4小，left向后找比4大的数，此时6比4大，交换0和6；
[4,1,3,0,9,2,8,6,7,5]
right向前找比4小的数，此时2比4小，left向后找比4大的数，此时9比4大，交换2和9；
[4,1,3,0,2,9,8,6,7,5]
这时将枢轴4和array[left]的值进行一次交换，就完成了第一趟快排。
[1,3,0,2,4,9,8,6,7,5]

快慢指针法

思想：

针对取最后一个元素作为枢轴的情况：
1、定义变量fast指向序列的开头，定义变量slow的前一个位置。
2、当array[fast] < key时，fast和slow同时往后走，如果array[fast]>key，fast往后走，slow留在大于key的数值前一个位置。
3、当array[fast]再次 < key时，交换array[fast]和array[slow]。

说白了就是，在没找到大于key值前，slow永远紧跟fast，遇到大于枢轴的值，两者之间就会拉开差距，中间差的肯定是连续的大于key的值，当再次遇到小于key的值时，交换两个下标对应的值就好了。

这里还是以[4,1,7,6,9,2,8,0,3,5]为例做解释。这里取5作为枢轴。
从数组左边开始找比5大的数字，4不比5大，fast++，slow++，1不比5大，fast++，slow++，此时fast指向7，slow指向1。这时，7比5大，fast++，slow不动，此时，fast指向的6仍比5大，fast++，slow仍不动，此时fast指向的9比5大，fast++，slow不动。此时fast指向的2比5小，则这时候slow++，指向7。此时，交换fast指向的2和slow指向的7。
[4,1,2,6,9,7,8,0,3,5]
接着，往后遍历，fast++，fast指向8，比5大，slow不动，fast++，fast指向0，0比5小，此时slow++，slow指向6。这时候，交换fast指向的0和slow指向的6。
[4,1,2,0,9,7,8,6,3,5]
接着，往后遍历，fast++，fast指向3，比5小，slow++，slow指向9，此时，将fast指向的3和slow指向的9交换。
[4,1,2,0,3,7,8,6,9,5]
最后，将枢轴5赋值给array[slow]。
[4,1,2,0,3,5,7,8,6,9]

###最好情况：最好的情况是枢轴选取得当，每次都能均匀的划分序列。时间复杂度O(nlogn)

###最坏情况：枢轴为最大或者最小数字，那么所有数都划分到一个序列去了。时间复杂度为O(n^2)

###比较和移动次数最少时间复杂度表示为O(nlogn);
###比较和移动次数最多的时间复杂度表示为O(n^2);
###使用的辅助存储空间最少为logn，最多为n^2；是不稳定的排序；

经典快排

思想：以数组最后一个数x作为枢轴（它一开始不参与遍历，从数组的第一位到枢轴的前一位参与遍历），从数组最左边的数字开始遍历，把小于等于x的数放在数组的左边，大于x的数放在数组的右边。这样的排序算法，每一次排序只搞定一个位置上的数在正确的位置上（划分区域的枢轴），确保其左边的数都小于等于它，右边的数都大于它。

缺点：选择的枢轴和数据的原始规模有关系，如果选择的枢轴正好是整个数组的中位数，那么这样小于枢轴的部分和大于枢轴的部分规模就相当了，这样处理问题的子规模就从原来的O(N)变成了O(logN)。如果选择的枢轴是整个数组的边界值(最小值或者最大值)，导致处理问题的子规模变成不一样大，那么处理问题的规模就会变成O(N2)。最好情况下，经典快排的算法复杂度是O(NlogN)，最差情况下，经典快排的算法复杂度是O(N2)。空间复杂度为O(1)。

public class Test{
	public static void quickSort(int [] arr,int L,int R) {
		if(L<R) {
			int[] p=patition(arr,L,R);
			quickSort(arr,L,p[0]-1);
			quickSort(arr,p[1]+1,R);
		}
	}
	public static int[] patition(int[] arr,int L,int R) {
		int less=L-1;
		int more=R;
		int cur=L;
		while(cur<more) {
			if(arr[cur]<arr[R]) {
				swap(arr,++less,cur++);
			}else if(arr[cur]>arr[R]) {
				swap(arr,--more,cur);
			}else {
				cur++;
			}
		}
		swap(arr,more,R);//当遍历结束之后(指针相遇)，将枢轴x与大于x的第一位上的数(数组下标为more的数)进行交换
		return new int[] {less+1,more};//less+1和more为数组中等于x的数在排序后的下标的左右临界位置
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];	
		arr[j]=temp;
	}
	public static void main(String[] args) {
		int[] arr= {6,3,4,3,1,3,8,5};
		quickSort(arr,0,arr.length-1);
		for(int i:arr) {
			System.out.print(i+" ");
		}
	}
}

输出：1 3 3 3 4 5 6 8

随机快排(最重要！！！最常用！！！)

思路：随机选择数组中的一个数x和数组最后一个数进行交换，然后用随机选择的数x来作为枢轴进行划分。这样的话，就不能说会轻易的找到最差的情况了，因为每一次排序选择的枢轴都是随机的，可能选择到最好情况的枢轴(中位数)，也有可能选择到最差情况的枢轴(边界值)，这样的话，它的复杂度就是一个概率事件了。所以在估计的时候就不能说它有一个最差情况了，只能用长期期望的方式来算出它的时间复杂度。这里有计算公式证明长期期望的时间复杂度是O(NlogN)。空间复杂度为O(logN)。空间复杂度浪费在了划分点p的位置上，每一次排序都要记下划分点位置，方便找到递归子过程的边界位置。

public class Test{
	public static void quickSort(int [] arr,int L,int R) {
		if(L<R) {
			swap(arr,L+(int)(Math.random()*(R-L+1)),R);//随机选择数组中的一个数和数组最后一个数进行交换
			int[] p=patition(arr,L,R);
			quickSort(arr,L,p[0]-1);
			quickSort(arr,p[1]+1,R);
		}
	}
	public static int[] patition(int[] arr,int L,int R) {
		int less=L-1;
		int more=R;
		int cur=L;
		while(cur<more) {
			if(arr[cur]<arr[R]) {
				swap(arr,++less,cur++);
			}else if(arr[cur]>arr[R]) {
				swap(arr,--more,cur);
			}else {
				cur++;
			}
		}
		swap(arr,more,R);//当遍历结束之后(指针相遇)，将枢轴x与大于x的第一位上的数(数组下标为more的数)进行交换
		return new int[] {less+1,more};//less+1和more为数组中等于x的数在排序后的下标的左右临界位置
	}
	public static void swap(int[] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];	
		arr[j]=temp;
	}
	public static void main(String[] args) {
		int[] arr= {6,3,4,3,1,3,8,5};
		quickSort(arr,0,arr.length-1);
		for(int i:arr) {
			System.out.print(i+" ");
		}
	}
}

输出：1 3 3 3 4 5 6 8