快速排序 Java

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

（就是他）

算法思想：

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

      伪代码如下：

            

1 public static void quickSort(int[] list){ 
2     if(list.length > 1){  
3     select a pivot; 
4     partition list into list1 and list2 such that all elements in  
5     list1 <= pivot and all elements in list2 > pivot;
6     quickSort(list1);  
7     quickSort(list2);   
8     }
9 }

 

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

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

               

     下图说明了如何划分数组(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

     

 

        具体代码如下：

        

 1 public class QuickSort {  
 2   
 3     private static int partition(int[] list, int first, int last) {  
 4         int pivot = list[first];//选择第一个元素作为主元  
 5         int low = first + 1;  
 6         int high = last;  
 7   
 8         while (high > low) {  
 9             //从左开始扫描  
10             while (low <= high && list[low] <= pivot) {  
11                 low++;  
12             }  
13             //从右开始扫描  
14             while (low <= high && list[high] > pivot) {  
15                 high--;  
16             }  
17   
18             //交换数组中的元素  
19             if (high > low) {  
20                 int temp = list[high];  
21                 list[high] = list[low];  
22                 list[low] = temp;  
23             }  
24         }  
25         while (high > first && list[high] >= pivot) {  
26             high--;  
27         }  
28   
29         if (pivot > list[high]) {  
30             list[first] = list[high];  
31             list[high] = pivot;  
32             return high;  
33         } else {  
34             return first;  
35         }  
36     }  
37       
38     public static void quickSort(int [] list){  
39         quickSort(list, 0 ,list.length - 1);  
40     }  
41       
42     private static void quickSort(int[] list,int first,int last){  
43         if(last > first){  
44             int pivotIndex = partition(list, first, last);  
45             quickSort(list, first, pivotIndex - 1);  
46             quickSort(list, pivotIndex + 1, last);  
47         }  
48     }  
49       
50     public static void main(String[] args){  
51         int[] list = {5,2,9,3,8,4,0,1,6,7};  
52         quickSort(list);  
53         for(int i = 0 ;i <list.length;i++)  
54             System.out.print(list[i] + " ");  
55     }  
56   
57 }  

 

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