用Objective-C實現幾種基本的排序演算法，並把排序的過程圖形化顯示。其實演算法還是挺有趣的 ^ ^.
- 選擇排序
- 氣泡排序
- 插入排序
- 快速排序
選擇排序
以升序為例。
選擇排序比較好理解，一句話概括就是依次按位置挑選出適合此位置的元素來填充。
- 暫定第一個元素為最小元素，往後遍歷，逐個與最小元素比較，若發現更小者，與先前的”最小元素”交換位置。達到更新最小元素的目的。
- 一趟遍歷完成後，能確保剛剛完成的這一趟遍歷中，最的小元素已經放置在前方了。然後縮小排序範圍，新一趟排序從陣列的第二個元素開始。
- 在新一輪排序中重複第1、2步驟，直到範圍不能縮小為止，排序完成。
選擇排序.gif
以下方法在NSMutableArray+JXSort.m中實現
|
1 2 3 4 5 6 7 8 9 10 11 12 |
- (void)jx_selectionSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback { if (self.count == 0) { return; } for (NSInteger i = 0; i < self.count - 1; i ++) { for (NSInteger j = i + 1; j < self.count; j ++) { if (comparator(self[i], self[j]) == NSOrderedDescending) { [self jx_exchangeWithIndexA:i indexB:j didExchange:exchangeCallback]; } } } } |
氣泡排序
- 在一趟遍歷中，不斷地對相鄰的兩個元素進行排序，小的在前大的在後，這樣會造成大值不斷沉底的效果，當一趟遍歷完成時，最大的元素會被排在後方正確的位置上。
- 然後縮小排序範圍，即去掉最後方位置正確的元素，對前方陣列進行新一輪遍歷，重複第1步驟。直到範圍不能縮小為止，排序完成。
氣泡排序.gif
|
1 2 3 4 5 6 7 8 9 10 11 12 |
- (void)jx_bubbleSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback { if (self.count == 0) { return; } for (NSInteger i = self.count - 1; i > 0; i --) { for (NSInteger j = 0; j < i; j ++) { if (comparator(self[j], self[j + 1]) == NSOrderedDescending) { [self jx_exchangeWithIndexA:j indexB:j + 1 didExchange:exchangeCallback]; } } } } |
插入排序
插入排序是從一個亂序的陣列中依次取值，插入到一個已經排好序的陣列中。這看起來好像要兩個陣列才能完成，但如果只想在同一個陣列內排序，也是可以的。此時需要想象出兩個區域：前方有序區和後方亂序區。
- 分割槽。開始時前方有序區只有一個元素，就是陣列的第一個元素。然後把從第二個元素開始直到結尾的陣列作為亂序區。
- 從亂序區取第一個元素，把它正確插入到前方有序區中。把它與前方無序區的最後一個元素比較，亦即與它的前一個元素比較。
- 如果比前一個元素要大，則不需要交換，這時有序區擴充一格，亂序區往後縮減一格，相當於直接拼在有序區末尾。
- 如果和前一個元素相等，則繼續和前二元素比較、再和前三元素比較……如果往前遍歷到頭了，發現前方所有元素值都長一個樣的話(囧)，那也可以，不需要交換，這時有序區擴充一格，亂序區往後縮減一格，相當於直接拼在有序區末尾。如果比前一個元素大呢？對不起作為有序區不可能出現這種情況。如果比前一個元素小呢，請看下一點。
- 如果比前一個元素小，則交換它們的位置。交換完後，繼續比較取出元素和它此時的前一個元素，若更小就交換，若相等就比較前一個，直到遍歷完成。
至此，把亂序區第一個元素正確插入到前方有序區中。
- 往後縮小亂序區範圍，繼續取縮小範圍後的第一個元素，重複第2步驟。直到範圍不能縮小為止，排序完成。
插入排序.gif
|
1 2 3 4 5 6 7 8 9 10 |
- (void)jx_insertionSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback { if (self.count == 0) { return; } for (NSInteger i = 1; i < self.count; i ++) { for (NSInteger j = i; j > 0 && comparator(self[j], self[j - 1]) == NSOrderedAscending; j --) { [self jx_exchangeWithIndexA:j indexB:j - 1 didExchange:exchangeCallback]; } } } |
快速排序
快排的版本有好幾種，粗略可分為：
- 原始的快排。
- 為製造適合高效排序環境而事先打亂陣列順序的快排。
- 為陣列內大量重複值而優化的三向切分快排。
這裡只討論原始的快排。
關於在快排過程中何時進行交換以及交換誰的問題，我看見兩種不同的思路：
- 當左右兩個遊標都停止時，交換兩個遊標所指向元素。樞軸所在位置暫時不變，直到兩個遊標相遇重合，才更新樞軸位置，交換樞軸與遊標所指元素。
- 當右遊標找到一個比樞軸小的元素時，馬上把樞軸交換到遊標所在位置，而遊標位置的元素則移到樞軸那裡。完成一次樞軸更新。然後左遊標再去尋找比樞軸大的元素，同理。
第1種思路可以有效降低交換頻率，在遊標相遇後再對樞軸進行定位，這步會導致略微增加了比較的次數；第2種思路交換操作會比較頻繁，但是在交換的過程中同時也把樞軸的位置不斷進行更新，當遊標相遇時，樞軸的定位也完成了。
在兩種思路都嘗試實現過後，我還是喜歡第2種，即便交換操作會多一些，但實質上的交換隻是對陣列特定位置的賦值，這種操作還是挺快的。
- 從待排序陣列中選一個值作為分割槽的參考界線，一般選第一個元素即可。這個選出來的值可叫做樞軸
pivot，它將會在一趟排序中不斷被移動位置，只終移動到位於整個陣列的正確位置上。 - 一趟排序的目標是把小於樞軸的元素放在前方，把大於樞軸的元素放在後方，樞軸放在中間。這看起來一趟排序實質上所幹的事情就是把陣列分割槽。接下來考慮怎麼完成一次分割槽。
- 記一個遊標
i，指向待排序陣列的首位，它將會不斷向後移動；
再記一個遊標j，指向待排序陣列的末位，它將會不斷向前移動。
這樣可以預見的是，i、j終有相遇時，當它們相遇的時候，就是這趟排序完成時。 - 現在讓遊標
j從後往前掃描，尋找比樞軸小的元素x，找到後停下來，準備把這個元素扔到前方去。 - 在同一個陣列內排序並不能擴大陣列的容量，那怎麼扔呢？
因為剛才把首位元素選作為pivot，所以當前它們的位置關係是pivot ... x。
又排序目標是升序，x是個小值卻放在了pivot的後方，不妥，需要交換它們的位置。 - 交換完後，它們的位置關係變成了
x ... pivot。此時j指向了pivot，i指向了x。 - 現在讓遊標
i向後掃描，尋找比樞軸大的元素y，找到後停下來，與pivot進行交換。
完成後的位置關係是pivot ... y，此時i指向pivot，即pivot移到了i的位置。 - 這裡有個小優化，在
i向後掃描開始時，i是指向x的，而在上一輪j遊標的掃描中我們已經知道x是比pivot小的，所以完全可以讓i跳過x，不需要拿著x和pivot再比較一次。
結論是在j遊標的交換完成後，順便把i往後移一位，i ++。
同理，在i遊標的交換完成後，順便把j往前移一位，j --。 - 在掃描的過程中如果發現與樞軸相等的元素怎麼辦呢？
因我們不討論三向切分的快排優化演算法，所以這裡答案是：不理它。
隨著一趟一趟的排序，它們會慢慢被更小的元素往後擠，被更大的元素往前擠，最後的結果就是它們都會和樞軸一起移到了中間位置。 - 當
i和j相遇時，i和j都會指向pivot。在我們的分割槽方法裡，把i返回，即在分割槽完成後把樞軸位置返回。 - 接下來，讓分出的兩個陣列分別按上述步驟各自分割槽，這是個遞迴的過程，直到陣列不能再分時，排序完成。
快速排序是很天才的設計，實現不復雜，關鍵是它真的很快~
快速排序.gif
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
- (void)jx_quickSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback { if (self.count == 0) { return; } [self jx_quickSortWithLowIndex:0 highIndex:self.count - 1 usingComparator:comparator didExchange:exchangeCallback]; } - (void)jx_quickSortWithLowIndex:(NSInteger)low highIndex:(NSInteger)high usingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback { if (low >= high) { return; } NSInteger pivotIndex = [self jx_quickPartitionWithLowIndex:low highIndex:high usingComparator:comparator didExchange:exchangeCallback]; [self jx_quickSortWithLowIndex:low highIndex:pivotIndex - 1 usingComparator:comparator didExchange:exchangeCallback]; [self jx_quickSortWithLowIndex:pivotIndex + 1 highIndex:high usingComparator:comparator didExchange:exchangeCallback]; } - (NSInteger)jx_quickPartitionWithLowIndex:(NSInteger)low highIndex:(NSInteger)high usingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback { id pivot = self[low]; NSInteger i = low; NSInteger j = high; while (i < j) { // 略過大於等於pivot的元素 while (i < j && comparator(self[j], pivot) != NSOrderedAscending) { j --; } if (i < j) { // i、j未相遇，說明找到了小於pivot的元素。交換。 [self jx_exchangeWithIndexA:i indexB:j didExchange:exchangeCallback]; i ++; } /// 略過小於等於pivot的元素 while (i < j && comparator(self[i], pivot) != NSOrderedDescending) { i ++; } if (i < j) { // i、j未相遇，說明找到了大於pivot的元素。交換。 [self jx_exchangeWithIndexA:i indexB:j didExchange:exchangeCallback]; j --; } } return i; } |
UI實現
現在講下UI的實現思路。
NSMutableArray+JXSort.h
從前面的排序程式碼可以看到，我是給NSMutableArray寫了個分類，排序邏輯寫在分類裡面，完全與檢視無關。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
typedef NSComparisonResult(^JXSortComparator)(id obj1, id obj2); typedef void(^JXSortExchangeCallback)(id obj1, id obj2); @interface NSMutableArray (JXSort) // 選擇排序 - (void)jx_selectionSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback; // 氣泡排序 - (void)jx_bubbleSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback; // 插入排序 - (void)jx_insertionSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback; // 快速排序 - (void)jx_quickSortUsingComparator:(JXSortComparator)comparator didExchange:(JXSortExchangeCallback)exchangeCallback; @end |
外部呼叫者只需要傳入兩個引數：
comparator程式碼塊。這是遵循蘋果原有API的風格設計，在需要比較陣列內的兩個元素時，排序方法將會呼叫這個程式碼塊，回傳需要比較的兩個元素給外部呼叫者，由外部呼叫者實現比較邏輯，並返回比較結果給排序方法。exchangeCallback程式碼塊。這個引數是實現檢視變化的關鍵。排序方法在每次完成兩個元素的交換時，都會呼叫這個程式碼塊。外部呼叫者，比如ViewController就可以知道排序元素每一次變換位置的時機，從而同步檢視的變化。
|
1 2 3 4 5 6 7 8 9 |
- (void)jx_exchangeWithIndexA:(NSInteger)indexA indexB:(NSInteger)indexB didExchange:(JXSortExchangeCallback)exchangeCallback { id temp = self[indexA]; self[indexA] = self[indexB]; self[indexB] = temp; if (exchangeCallback) { exchangeCallback(temp, self[indexA]); } } |
ViewController.m
檢視控制器持有待排序的陣列，這個陣列是100條細長的矩形，長度隨機。
|
1 |
@property (nonatomic, strong) NSMutableArray<UIView *> *barArray; |
由於我們加強了NSMutableArray，它現在可以支援多種指定型別的排序了，同時也可以把排序過程反饋給我們，當需要給barArray排序時，只需要這樣呼叫：
|
1 2 3 4 5 6 7 |
- (void)quickSort { [self.barArray jx_quickSortUsingComparator:^NSComparisonResult(id obj1, id obj2) { return [self compareWithBarOne:obj1 andBarTwo:obj2]; } didExchange:^(id obj1, id obj2) { [self exchangePositionWithBarOne:obj1 andBarTwo:obj2]; }]; } |
每一次didExchange的回撥，ViewController都會對兩個檢視的位置進行交換。如此形成不斷進行排序的視覺效果。
控制排序速度
為了能夠讓肉眼感知排序的過程，我們需要放慢排序的過程。這裡我的辦法是延長兩個元素比較操作的耗時，大約延長到0.002秒。結果很明顯，當某個演算法所需要進行的比較操作越少時，它排序就會越快(根據上面四張圖的比較，毫無疑問快排所進行的比較操作是最少啦~)。
那麼如何模擬出比較操作的耗時時間呢？
這裡我的辦法是藉助訊號量，在兩條執行緒間通訊。
1.讓排序在子執行緒中進行，當需要進行比較操作時，阻塞執行緒，等待訊號的到來。這裡的思想是得到一個訊號才能進行一次比較。
|
1 2 3 4 5 6 7 8 9 10 11 |
- (NSComparisonResult)compareWithBarOne:(UIView *)barOne andBarTwo:(UIView *)barTwo { // 模擬進行比較所需的耗時 dispatch_semaphore_wait(self.sema, DISPATCH_TIME_FOREVER); CGFloat height1 = CGRectGetHeight(barOne.frame); CGFloat height2 = CGRectGetHeight(barTwo.frame); if (height1 == height2) { return NSOrderedSame; } return height1 < height2 ? NSOrderedAscending : NSOrderedDescending; } |
2.主執行緒啟用定時器，每隔0.002秒發出一個訊號，喚醒排序執行緒。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
self.sema = dispatch_semaphore_create(0); NSTimeInterval nowTime = [[NSDate date] timeIntervalSince1970]; // 定時器訊號 __weak typeof(self) weakSelf = self; self.timer = [NSTimer scheduledTimerWithTimeInterval:0.002 repeats:YES block:^(NSTimer * _Nonnull timer) { // 發出訊號量，喚醒排序執行緒 dispatch_semaphore_signal(weakSelf.sema); // 更新計時 NSTimeInterval interval = [[NSDate date] timeIntervalSince1970] - nowTime; weakSelf.timeLabel.text = [NSString stringWithFormat:@"耗時(秒):%2.3f", interval]; }]; |
原始碼
https://github.com/JiongXing/JXSort
參考
Swift演算法俱樂部中文版 — 插入排序
演算法筆記－排序01:選擇排序,插入排序,希爾排序
演算法筆記－排序02:歸併排序,快速排序
1.2-交換排序-快速排序