Michael Tsai
2012/5/15
Sorting
•
定義 :•
Input: 為 n 個數字的序列•
Output: 為輸入之序列的重新排列，使得•
真實的情況中 , 為一組 (record) 中的 key ( 例如學號 )•
record 中除了 key 以外的資料稱為 satellite data•
如果 satellite data 很大， 我們通常在排序的時候只排 列指到該 record 的 pointer 。•
Sorting 有什麼用 ?
•
例子一 : 在一個 list 裡面找東西 .•
如果沒有 sort 過 , 要怎麼找 ?•
答 : 只能苦工 , 從頭找到尾 •
那如果 sort 過呢 ?•
繼續苦工的話有幫助嗎 ?•
有 . 可以提早知道要找的數字不在裡面 .•
也可以 binary search •
但是 , sorting 本身要花多少時間呢…•
Sorting 有什麼用 ?
• 例子二 : 比對兩個 list 有沒有一樣 ( 列出所有不一樣的 item). 兩個 l ists 分別有 n 與 m 個 items.
• 如果沒有 sort 要怎麼找呢 ?
• list 1 的第 1 個 , 比對 list 2 的 1-m 個
• list 1 的第 2 個 , 比對 list 2 的 1-m 個
• …
• list 1 的第 n 個 , 比對 list 2 的 1-m 個
• 所以需要
• 如果 sort 過呢 ?
• 不要忘了還有 sorting 的時間
• 所以 sorting 究竟要花多少時間呢 ?
•
Sorting 的分類
•
Internal Sort: 所有的資料全部可以一股腦地放在記憶體 裡面•
External Sort: 資料太大了 , 有些要放到別的地方 ( 硬 碟 , 記憶卡 , 網路上的其他電腦上 , 等等等 )•
我們只講 internal sort 的部分•
現在電腦 ( 及如手機 , iPod, iPad 等各種計算裝置 ) 記 憶體越來越大 , 越來越便宜 , 比較少有機會使用 externa l sort.Sorting 相關名詞
•
Stability: 如果 ( 一樣大的 key) ，那麼它們在 sort 前 的順序和 sort 之後的順序是一樣的。•
In-place: 直接在原本儲存這些 key 的記憶體位置做 sort 。 因此只需要額外 O(1) 的記憶體大小來幫助 sorting 。•
Adaptability: 如果數列已經有部分排過序了，則 sortin g 的 time complexity 可因此而降低。•
到底我們可以 sort 多快 ?
•
假設我們使用”比較” +” 交換”的方法 .•
“ 比較” : 看 list 裡面的兩個 item 誰大誰小•
“ 交換” : 交換 / 移動兩個 item 在 list 裡面的位置•
如何歸納出”最差的狀況要花多少時間 sort?”�
1≤ �
2�
2≤ �
3�
1≤ �
3�
1≤ �
3�
2≤ �
3stop stop
stop
stop
stop stop
[1,2,3]
[1,3,2]
[1,2,3]
[1,2,3]
[1,3,2]
[2,3,1]
[2,1,3]
[2,1,3]
[3,1,2]
[3,1,2] [3,2,1]
Yes No
Decision tree for sorting
•
每個 node 代表一個 comparison 及 swap•
到達 leaf 時表示 sorting 完畢•
共有幾個 leaf?•
共有 n 個 items 的所有可能排列數目 :•
�
1≤ �
2�
2≤ �
3�
1≤ �
3�
1≤ �
3stop stop
stop
stop
stop stop
[1,2,3]
[1,3,2]
[1,2,3]
[1,2,3]
[1,3,2]
[2,3,1]
[2,1,3]
[2,1,3]
[3,1,2] [3,2,1]
�
2≤ �
3到底我們可以 sort 多快 ?
•
所以 , worst case 所需要花的時間 , 為此 binary tree 的 height.•
如果 decision tree height 為 h, 有 l 個 leaves•
, 因為至少要有 n! 個 leaves•
, 高度為 h 的 binary tree (decision tree) 最多有個 leaf•
結論 : 任何以”比較”為基礎的 sorting algorithm wors t-case complexity 為 .•
複習 : Selection Sort
•
第一次選最小的 , 移到最前面•
第二次選第二小的 , 移到第二前面•
….•
直到剩一個 ( 最大的 ), 會放在最後面ㄅ ㄆ 1
1 ㄆ 2 ㄅ
1 2 ㄆ ㄅ
複習 : Selection Sort
•
因為 selection sort 並不因為目前的狀況而改變演算法執 行的步驟 ( 總是從頭看到尾 )•
所以 best-case, worst-case, average-case 都是•
(Not adaptive)•
In-place•
Insertion Sort
•
方法 : 每次把一個 item 加到已經排好的 , 已經有 i 個 it em 的 list, 變成有 i+1 個 item 的排好的 list2 3 6 5 1 4
2 3 6 5 1 4
2 3 6 5 1 4
2 3 5 6 1 4
2 3 5 6 1 4
1 2 3 5 6 4
1 2 3 5 6 4
1 2 3 4 5 6
Insertion Sort
• 要花多少時間 ?
• 答 : 最差的狀況 , 每次都要插到最末端 ( 花目前 sorted 大小的時間 )
• 平均 complexity, 也是 . (Why?)
• 變形 ( 蟲 ):
• 1. 在找正確的應該插入的地方的時候 , 使用 binary sear ch. ( 但是移動還是
• 2. 使用 linked list 來表示 整個 list 的 item, 則插入 時不需要移動 , 為 . ( 但是尋找插入的地方的時候還是需 要 )
•
Insertion Sort 的好性質
•
簡單 (time complexity 中的 constant 小 )• 當需要 sort 的東西很少的時候 , 常常被拿來使用
•
Stable•
In-place•
Adaptive: 當有部分排好的時候會比較快• 舉例 : 中 , 只有 <5,3>, <5,4> 兩組數字反了 (inversion)
• 使用 insertion sort 的時間為 O(n+d), d 為 inversion 數目 ( 上 例中為 2)
• ( 根據以上 ) Best case: O(n) ( 沒有 inversion, 已經排好了 )
•
Online:不需要一開始就知道所有需要被排序的數字 , 可以一面收 入一面排序
•
Merge Sort
•
使用 Divide-and-Conquer 的策略•
Divide-and-Conquer:• Divide: 把大問題切成小問題
• Conquer: 解決小問題
• Combine: 把小問題的解答合起來變成大問題的解答
•
Merge sort:• Divide: 把 n 個數字切成兩個數列 ( 各 n/2 個數字 )
• Conquer: 將兩個子數列各自排序 ( 事實上是用 recursive call 交 給下面處理 )
• Combine: 將 return 回來的兩個各自排好的子數列合併起來變成大 的數列
Merge Sort
void Mergesort(int A[], int temp, int left, int right) { int mid;
if (right > left) {
mid=(right+left)/2;
Mergesort(A,temp,left,mid);
Mergesort(A,temp,mid+1,right);
Merge(A,temp,left,mid+1,right);
} }
Divide
Conque Combinr e
Merge Sort: Example
How to combine? (Karumanchi p251)
1 4 5 8 2 3 6 9
1 2 3 4 5 6 8 9
left mid
•
要怎麼把兩個已經排好的 list merge 成一個 ?•
所花時間 : , n 和 m 為兩個要合併的 list 長度•
Merge 完需要再從暫時的儲存把資料搬回原本的 input array
暫時的儲存 原本的位置
Merge sort
•
每個” pass”, 正好每個要排序的數字都 process 了一次 .所以為
•
總共需要多少” pass” 呢 ?•
每次一個子序列的長度會變兩倍 , 最後變成一個大序列有 n 個數•
所以需要 passes.•
總共所需時間為•
Worst-case, best-case, average-case 時間都一樣 :•
需要額外的空間來 sorting: 用來儲存 merge 好的結果•
額外空間 : O(n)•
複習 : Heapsort
•
如何利用 heap 排序 ?1.
先用 heapify 方法把整個 array 變成 heap.2.
每次從 heap 拿出一個最大的 , ( 和尾巴交換 ), 然後把 原本尾巴的 element 依序往下檢查 / 交換直到符合 heap 性質 .3.
重複步驟 2 一直到 heap 變成空的 .�(�)
�(�log �)
Total:
Quick Sort
•
方法 : 每次找出一個 pivot( 支點 ), 所有它左邊都比它 小 ( 但是沒有 sort 好 ), 所有它右邊都比它大 , 然後再 c all 自己去把 pivot 左邊與 pivot 右邊排好 .26 5 37 1 61 11 59 15 48 19
26 5 37 1 61 11 59 15 48 19
26 5 19 1 61 11 59 15 48 37
26 5 19 1 15 11 59 61 48 37 11 5 19 1 15 26 59 61 48 37
Quick Sort
11 5 19 1 15 26 59 61 48 37 1 5 11 19 15 26 59 61 48 37 1 5 11 19 15 26 59 61 48 37 1 5 11 15 19 26 59 61 48 37 1 5 11 15 19 26 59 61 48 37 1 5 11 15 19 26 48 37 59 61 1 5 11 15 19 26 37 48 59 61 1 5 11 15 19 26 37 48 59 61
Quick Sort: Worst & Best case
•
但是 Worst case 時所需時間還是•
想想看 , 什麼時候會變成這樣呢 ?•
答 : 每次 pivot 都是最大的 . (or 每次都是最小的 ) 已經排好了 !•
此時居然執行時間為•
Best case?•
每次 pivot 正好都可以把數列很平均地分成兩半•
因此 T(n)=2T(n/2)+•
T(n)=•
Randomized Quick Sort
•
避免常常碰到 worst case ( 已經排好的狀況 )•
選擇 pivot 的時候 , 不要固定選最左邊的•
亂數選擇需要分類的範圍中其中一個作為 pivot•
這樣減少碰到 worst 的機率 ( 但碰到 worst case 還是 )•
26 5 37 1 61 11 59 15 48 19 亂數選擇一個當 pivot
先交換
Average running time
•
越能選到 pivot 可以平均的分配成兩個 subset 越好•
以下我們將說明為什麼 average running time 會接近 bes t-case•
假設很糟的一個狀況 : 每次都分成 1:9•
分成 9/10 的那一份所需花的時間
分成 1/10 的那一份所需花的時間
分成比 pivot 大或小所花的時間
Average running time
只要切分的 pivot 可以大略切一個比例 ( 即 使這個比例很不平衡 ), 依然可以得到
Average running time
第一層分得很差 但是下一層分得很好
第一層就分得很好
第一層切分花了
第二層切分花了
第一層切分花了
Θ
( � ) +Θ ( �− 1 ) =Θ (�)
居然一樣 !
( 只是分得比較差的 constant 比較大而 已 )分得比較好的層會”吸 收”分得比較差的層造 成的額外時間
比較四大金剛
• Insertion sort: n 小的時候非常快速 . ( 因為常數 c 小 )
• Quick sort: average performance 最好 (constant 也小 )
• Merge sort: worst-case performance 最好
• Heap sort: worst-case performance 不錯 , 且不用花多的空間
• 可以 combine insertion sort 和其他 sort
• 怎麼 combine?
• 答 : 看 n 的大小決定要用哪一種 sorting algorithm.
Worst Average Additional Space?
Insertion sort O(1)
Heap sort O(1)
Merge sort O(n)
Quick sort O(1)
Worst Average Additional Space?
Insertion sort O(1)
Heap sort O(1)
Merge sort O(n)
Quick sort O(1)
Today’s Reading Assignments
• Cormen p146-150 (preface of section II):
• 了解排序演算法的背景
• Cormen 7.2-7.3
• Karumanchi 10.5-7, 10.8-10.11
• Errata of Karumanchi Ch10:
• P.245: Some sorting algorithms are “in place” and they nee d O(1) or O(log n) memory to create auxiliary locations for sorting the data temporarily.
• P.248: Performance of Selection Sort:
• Best case complexity should be , not
• P.249: Performance of Insertion Sort:
• Best case complexity should be , not
• Worst case space complexity should be total, not total.
