交换排序—快速排序（Quick Sort）原理以及Java实现

交换排序—快速排序（Quick Sort）

基本思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

快速排序的示例：

（a）一趟排序的过程：



快速排序里的挖坑填补法：以49为标准值，从右开始找比49小的值，首先是27，把27放在49的那个位置，把49放在27的位置，在从左找比49大的值65，把65放在49的新位置（原27的位置）之后变成 27，38，49，97，76，13，65.49

在新的一轮开始，从右开始找49 小的数是13，把13放在49的位置，49放在13的位置，在从左找比49大的数97，把97放在49的新位置上（原13的位置）变成27，38，13，49，76，97，65，49

（b）排序的全过程



算法的实现：

1 /**
2  *
3  * @author zhangtao
4  */
5 public class QuickSort {
6
7     public static void main(String[] args) {
8         int arr[] = {49, 38, 65, 97, 76, 13, 27, 49};
9         quickSort(arr, 0, arr.length - 1);
10     }
11
12     //打印每次的排序结果
13     static void printLine(int[] arr) {
14         int Arrlength = arr.length;
15         for (int j = 0; j < Arrlength; j++) {
16             System.out.print(arr[j] + "  ");
17         }
18         System.out.println();
19     }
20
21     static int partition(int a[], int low, int high) {
22         int privotKey = a[low];                                 //基准元素
23         while (low < high) {                                    //从表的两端交替地向中间扫描
24             while (low < high && a[high] >= privotKey) //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端
25             {
26                 --high;                                         //从右找比基准元小的
27             }
28             a[low] = a[high];                                    //如果比基准元素小，交换
29             a[high] = privotKey;
30
31             while (low < high && a[low] <= privotKey) {
32                 ++low;                                          //从右找比基准元大的
33             }
34             a[high] = a[low];                                    //如果比基准元素，交换
35             a[low] = privotKey;
36
37         }
38         printLine(a);
39         return low;
40     }
41     //快速排序
42
43     static void quickSort(int a[], int low, int high) {
44         if (low < high) {
45             int privotLoc = partition(a, low, high);  //将表一分为二
46             quickSort(a, low, privotLoc - 1);          //递归对低子表递归排序
47             quickSort(a, privotLoc + 1, high);        //递归对高子表递归排序
48         }
49     }
50 }

分析：

快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。