八大排序算法之快速排序（二）

public static void kuaisu(int arr[],int low,int high) {
if(high>low) {
	int i=low;
	int j=high;
	
	int x=arr[i];
	while(j>i && arr[j]>=x) {
		j--;
	}
	if(j>i) {
		arr[i++]=arr[j];
	
	}
	while(j>i && arr[i]<x) {
		i++;
	}
	if(j>i) {
		arr[j--]=arr[i];
	
	}
	arr[i]=x;
	kuaisu(arr,i+1,high);
	kuaisu(arr,low,i-1);
}
	
	
}
public static void main(String[] args) {
	// TODO Auto-generated method stub
	int arr1[]=new int[] {2,3,46,78,96,53,76,32,67,9,7,4,54,37,19,10};
	int arr3[]={6,5,4,3,2,1,0};
	int arr2[]={2,3,46,78,96,53,76,32,67,9,7,4,54,37,19,10};
	kuaisu(arr3, 0, arr3.length-1);
for(int s:arr3) {
System.out.print(s+",");
}
}

快速排序的基本思想是

1、先从数列中取出一个数作为基准数

2、分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边

3、再对左右区间重复第二步，直到各区间只有一个数

概括来说为 挖坑填数+分治法

下面举例来进行说明，主要有三个参数，i为区间的开始地址，j为区间的结束地址，X为当前的开始的值

第一步，i=0,j=9,X=21

0	1	2	3	4	5	6	7	8	9
21	32	43	98	54	45	23	4	66	86

第二步，从j开始由，后向前找，找到比X小的第一个数a[7]=4,此时i=0,j=6,X=21 
进行替换

0	1	2	3	4	5	6	7	8	9
4	32	43	98	54	45	23	21	66	86

第三步，由前往后找，找到比X大的第一个数a[1]=32,此时i=2,j=6,X=21

0	1	2	3	4	5	6	7	8	9
4	21	43	98	54	45	23	32	66	86

第四步，从j=6开始由，由后向前找，找到比X小的第一个数a[0]=4,此时i=2,j=0,X=21，发现j<=i,所以第一回结束

可以发现21前面的数字都比21小，后面的数字都比21大 
接下来对两个子区间[0,0]和[2,9]重复上面的操作即可

下面直接给出过程，就步详细解说了

i=2,j=6,X=43

0	1	2	3	4	5	6	7	8	9
4	21	43	98	54	45	23	32	66	86

i=4,j=6,X=43

0	1	2	3	4	5	6	7	8	9
4	21	32	98	54	45	23	43	66	86

i=4,j=5,x=43

0	1	2	3	4	5	6	7	8	9
4	21	32	43	54	45	23	98	66	86

i=5,j=5,x=43

0	1	2	3	4	5	6	7	8	9
4	21	32	23	43	45	54	98	66	86

然后被分为了两个子区间[2,3]和[5,9]

….最后排序下去就是最终的答案

0	1	2	3	4	5	6	7	8	9
4	21	23	32	43	45	54	66	86	98

总结：

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j–由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的，大多数情况下总是最好的。

快速排序是不稳定的。

稳定性简单来说就是：

如果A i == A j，Ai 原来在 Aj 位置前，排序后 Ai  仍然是在 Aj 位置前，这样就是稳定的。