数据结构排序之快速排序

</pre><p><strong></strong><pre name="code" class="java">package offer.m4.sort;

/**
* 快速排序：平均时间复杂度O(nlogn)，最坏时间复杂度：O(n*n)
* 思想：有一个中心抽，根据这个将数组分成两部分，一部分全部大于轴，一部分全部小于轴
* 		在对左右两边递归调用
* partition函数
* 快速排序函数
* 主函数
* @author fangjie
*
*/
public class QuickSort {

public void quickSort(int[] array,int start,int end){
if(start<end){
int midIndex = partition(array, start, end);
quickSort(array, start, midIndex-1);
quickSort(array, midIndex+1, end);
}
}

private int partition(int[] array,int start,int end){
//随机选取start与end之间的一个整数，
//防止选取某个特定的值，而且数组又是有序导致快速排序性能下降的情况
int midIndex = randomIndex(start, end);
System.out.println("start: "+start+" end: "+end +"随机数为: "+midIndex);
//选取中心值
int midValue=array[midIndex];
if(midIndex!=start){ //优化
swap(array, start, midIndex);
}
while(start<end){
while(start<end && array[end]>midValue){
end--;
}
array[start] = array[end];

while(start < end && array[start]<midValue){
start++;
}
array[end] = array[start];
}
array[start] = midValue;

return start;
}
/**
* 交换数组中指定位置的两个数
* @param array
* @param i：要交换数的下标
* @param j：要交换数的下标
*/
private void swap(int[] array,int i,int j){
if(i==j) return ;
//不使用额外空间交换两个数
array[i] = array[i]+array[j];
array[j] = array[i]-array[j];
array[i] = array[i]-array[j];
//这是使用额外空间交换两个数,这到无所谓
/*int temp =array[i];
array[i] = array[j];
array[j] = temp;*/
}
/**
* 随机选取start与end之间的数，包括start和end
* @param start
* @param end
* @return
*/
private int randomIndex(int start,int end){
return  (int)(Math.random()*(end-start))+start;
}

public void print(int[] array){
System.out.print("{");
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]);
if(i!=array.length-1){
System.out.print(", ");
}
}
System.out.println("}");
}

public static void main(String[] args) {
QuickSort quickSort = new QuickSort();
System.out.println(quickSort.randomIndex(7,9));
int[] array=new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };
System.out.println("排序前：");
quickSort.print(array);
quickSort.quickSort(array, 0, array.length-1);
System.out.println("排序后：");
quickSort.print(array);

}
}