快速排序解析 Java

      快速排序由C. A. R. Hoare在1962年提出，是对冒泡排序的一种改进。
      

（就是他）

      算法思想：

            在数组中选择一个称为
主元 的元素，然后将数组分为两部分，使得第一部分的所有元素都小于等于主元，第二部分的所有元素都大于主元。然后       分别对第一部分和第二部分递归应用快速排序算法。

            伪代码如下：

</pre><pre name="code" class="java">public static void quickSort(int[] list){

if(list.length > 1){

select a pivot;

partition list into list1 and list2 such that all elements in 

list1 <= pivot and all elements in list2 > pivot;

quickSort(list1);

quickSort(list2); 

}
}

               每次划分后都将主元放到适当的位置，主元的选择会影响算法的性能。理想情况下，应该选择平均划分两部分的主元。

               为了简单，一般选择第一个元素或者选择最后一个元素作为主元。本例采用第一个元素作为主元

               

               下图说明了如何划分数组(5 2 9 3 8 4 0 1 6 7)

                ①选择第一个元素5作为主元，开始时low是指向元素2的下标，high指向元素7

                ②推进下标low查找第一个大于主元的元素(9)，并后退下标high查找第一个小于等于主元的元素(1)

                ③交换9和1

                ④继续查找，移动low指向元素8，移动high指向元素0

                ⑤交换8和0

                ⑥继续移动low直到它越过high，当所有元素都检查以后，交换主元与下标high处的元素4

                   


                 
具体代码如下：

                 public class QuickSort {

private static int partition(int[] list, int first, int last) {
int pivot = list[first];//选择第一个元素作为主元
int low = first + 1;
int high = last;

while (high > low) {
//从左开始扫描
while (low <= high && list[low] <= pivot) {
low++;
}
//从右开始扫描
while (low <= high && list[high] > pivot) {
high--;
}

//交换数组中的元素
if (high > low) {
int temp = list[high];
list[high] = list[low];
list[low] = temp;
}
}
while (high > first && list[high] >= pivot) {
high--;
}

if (pivot > list[high]) {
list[first] = list[high];
list[high] = pivot;
return high;
} else {
return first;
}
}

public static void quickSort(int [] list){
quickSort(list, 0 ,list.length - 1);
}

private static void quickSort(int[] list,int first,int last){
if(last > first){
int pivotIndex = partition(list, first, last);
quickSort(list, first, pivotIndex - 1);
quickSort(list, pivotIndex + 1, last);
}
}

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

}
             平均时间复杂度为O(nlogn)