歡迎光臨
每天分享高質量文章

排序演算法總結(2):快速排序

(點擊上方公號,快速關註我們)


來源:靜默虛空
www.cnblogs.com/jingmoxukong/p/4302891.html

要點

快速排序是一種交換排序。

快速排序由C. A. R. Hoare在1962年提出。

它的基本思想是:通過一趟排序將要排序的資料分割成獨立的兩部分:分割點左邊都是比它小的數,右邊都是比它大的數。

然後再按此方法對這兩部分資料分別進行快速排序,整個排序過程可以遞迴進行,以此達到整個資料變成有序序列。

詳細的圖解往往比大堆的文字更有說明力,所以直接上圖:

上圖中,演示了快速排序的處理過程:

初始狀態為一組無序的陣列:2、4、5、1、3。

經過以上操作步驟後,完成了第一次的排序,得到新的陣列:1、2、5、4、3。

新的陣列中,以2為分割點,左邊都是比2小的數,右邊都是比2大的數。

因為2已經在陣列中找到了合適的位置,所以不用再動。

2左邊的陣列只有一個元素1,所以顯然不用再排序,位置也被確定。(註:這種情況時,left指標和right指標顯然是重合的。因此在代碼中,我們可以通過設置判定條件left必須小於right,如果不滿足,則不用排序了)。

而對於2右邊的陣列5、4、3,設置left指向5,right指向3,開始繼續重覆圖中的一、二、三、四步驟,對新的陣列進行排序。

核心代碼

public int division(int[] listint left, int right) {
    // 以最左邊的數(left)為基準
    int base = list[left];
    while (left         // 從序列右端開始,向左遍歷,直到找到小於base的數
        while (left list
[right] >= base)
            right--;
        // 找到了比base小的元素,將這個元素放到最左邊的位置
        list[left] = list[right];

        // 從序列左端開始,向右遍歷,直到找到大於base的數
        while (left list[left] <= base)
            left++;
        // 找到了比base大的元素,將這個元素放到最右邊的位置
        list[right] = list[left];
    }

    // 最後將base放到left位置。此時,left位置的左側數值應該都比left小;
    // 而left位置的右側數值應該都比left大。
    list[left] = base;
    return left;
}

private void quickSort(int[] listint left, int right) {

    // 左下標一定小於右下標,否則就越界了
    if (left         // 對陣列進行分割,取出下次分割的基準標號
        int base = division(list, left, right);

        System.out.format("base = %d:"list[base]);
        printPart(list, left, right);

        // 對“基準標號“左側的一組數值進行遞迴的切割,以至於將這些數值完整的排序
        quickSort(list, left, base - 1);

        // 對“基準標號“右側的一組數值進行遞迴的切割,以至於將這些數值完整的排序
        quickSort(list, base + 1, right);
    }
}
演算法分析

快速排序演算法的性能

時間複雜度

當資料有序時,以第一個關鍵字為基準分為兩個子序列,前一個子序列為空,此時執行效率最差。

而當資料隨機分佈時,以第一個關鍵字為基準分為兩個子序列,兩個子序列的元素個數接近相等,此時執行效率最好。

所以,資料越隨機分佈時,快速排序性能越好;資料越接近有序,快速排序性能越差。

空間複雜度

快速排序在每次分割的過程中,需要 1 個空間儲存基準值。而快速排序的大概需要 Nlog2N次的分割處理,所以占用空間也是 Nlog2N 個。

演算法穩定性

在快速排序中,相等元素可能會因為分割槽而交換順序,所以它是不穩定的演算法。

完整參考代碼

JAVA版本

代碼實現

 1 public class QuickSort {
 2  
 3     public int division(int[] listint left, int right) {
 4         // 以最左邊的數(left)為基準
 5         int base = list[left];
 6         while (left  7             // 從序列右端開始,向左遍歷,直到找到小於base的數
 8             while (left list
[right] >= base)
 9                 right--;
10             // 找到了比base小的元素,將這個元素放到最左邊的位置
11             list[left] = list[right];
12  
13             // 從序列左端開始,向右遍歷,直到找到大於base的數
14             while (left list[left] <= base)
15                 left++;
16             // 找到了比base大的元素,將這個元素放到最右邊的位置
17             list[right] = list[left];
18         }
19  
20         // 最後將base放到left位置。此時,left位置的左側數值應該都比left小;
21         // 而left位置的右側數值應該都比left大。
22         list[left] = base;
23         return left;
24     }
25  
26     private void quickSort(int[] listint left, int right) {
27  
28         // 左下標一定小於右下標,否則就越界了
29         if (left 30             // 對陣列進行分割,取出下次分割的基準標號
31             int base = division(list, left, right);
32  
33             System.out.format("base = %d:"list[base]);
34             printPart(list, left, right);
35  
36             // 對“基準標號“左側的一組數值進行遞迴的切割,以至於將這些數值完整的排序
37             quickSort(list, left, base - 1);
38  
39             // 對“基準標號“右側的一組數值進行遞迴的切割,以至於將這些數值完整的排序
40             quickSort(list, base + 1, right);
41         }
42     }
43  
44     // 打印序列
45     public void printPart(int[] listint begin, int end) {
46         for (int i = 0; i 47             System.out.print("");
48         }
49         for (int i = begin; i <= end; i++) {
50             System.out.print(list[i] + "");
51         }
52         System.out.println();
53     }
54  
55     public static void main(String[] args) {
56         // 初始化一個序列
57         int[] array = {
58                 1345269780
59         };
60  
61         // 呼叫快速排序方法
62         QuickSort quick = new QuickSort();
63         System.out.print("排序前:");
64         quick.printPart(array0array.length - 1);
65         quick.quickSort(array0array.length - 1);
66         System.out.print("排序後:");
67         quick.printPart(array0array.length - 1);
68     }
69 }

運行結果

排序前:    1  3  4  5  2  6  9  7  8  0 
base = 1: 0  1  4  5  2  6  9  7  8  3 
base = 4:         3  2  4  6  9  7  8  5 
base = 3:         2  3 
base = 6:                    5  6  7  8  9 
base = 7:                            7  8  9 
base = 8:                                8  9 
排序後:    0  1  2  3  4  5  6  7  8  9 

相關係列:

排序演算法總結(1):冒泡排序

【關於投稿】


如果大家有原創好文投稿,請直接給公號發送留言。


① 留言格式:
【投稿】+《 文章標題》+ 文章鏈接

② 示例:
【投稿】
《不要自稱是程式員,我十多年的 IT 職場總結》:

http://blog.jobbole.com/94148/


③ 最後請附上您的個人簡介哈~



覺得本文有幫助?請分享給更多人

關註「演算法愛好者」,修煉編程內功

赞(0)

分享創造快樂