在Object-C中學習排序算法

作者：佚名 2017-08-04 17:44:02

在這次重新學習數據結構與算法的過程中筆者充分認識到了學習這些所謂的基礎知識的重要性，了解了要想進一步提供iOS開發的水平恰恰不能忽視基礎環節，也恰好在這次學習中用到了圖的深度遍歷解決了在研究埋點過程中找到回溯源的問題。  

筆者在學習數據結構與算法時，嘗試著將排序算法以動畫的形式呈現出來更加方便理解記憶，本文配合[Demo 在Object-C中學習數據結構與算法之排序算法](https://github.com/MisterBooo/Play-With-Sort-OC)閱讀更佳。

* 選擇排序

* 冒泡排序

* 插入排序

* 快速排序

* 雙路快速排序

* 三路快速排序

* 堆排序

* 總結與收獲

* 參考與閱讀

選擇排序

選擇排序是一種簡單直觀的排序算法，無論什么數據進去都是 O(n?) 的時間復雜度。所以用到它的時候，數據規模越小越好。唯一的好處可能就是不占用額外的內存空間了吧。

1.算法步驟

1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2. 再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。

3. 重復第二步，直到所有元素均排序完畢。

2.代碼實現

#pragma mark - /**選擇排序*/ 
- (void)mb_selectionSort{ 
    for (int i = 0; i < self.count; i++) { 
        for (int j = i + 1; j < self.count ; j++) { 
            if (self.comparator(self[i],self[j]) == NSOrderedDescending) { 
                [self mb_exchangeWithIndexA:i  indexB:j]; 
            } 
        } 
    } 
}

冒泡排序

冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

1.算法步驟

1. 比較相鄰的元素。如果***個比第二個大，就交換他們兩個。

2. 對每一對相鄰元素作同樣的工作，從開始***對到結尾的***一對。這步做完后，***的元素會是***的數。

3. 針對所有的元素重復以上的步驟，除了***一個。

4. 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

2.代碼實現

#pragma mark - /**冒泡排序*/ 
- (void)mb_bubbleSort{ 
    bool swapped; 
    do { 
        swapped = false; 
        for (int i = 1; i < self.count; i++) { 
            if (self.comparator(self[i - 1],self[i]) == NSOrderedDescending) { 
                swapped = true; 
                [self mb_exchangeWithIndexA:i  indexB:i- 1]; 
            } 
        } 
    } while (swapped); 
}

插入排序

插入排序的代碼實現雖然沒有冒泡排序和選擇排序那么簡單粗暴，但它的原理應該是最容易理解的了，因為只要打過撲克牌的人都應該能夠秒懂。插入排序是一種最簡單直觀的排序算法，它的工作原理是通過構建有序序列，對于未排序數據，在已排序序列中從后向前掃描，找到相應位置并插入。

1.算法步驟

1. 將***待排序序列***個元素看做一個有序序列，把第二個元素到***一個元素當成是未排序序列。

2. 從頭到尾依次掃描未排序序列，將掃描到的每個元素插入有序序列的適當位置。（如果待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的后面。）

2.代碼實現

#pragma mark - /**插入排序*/ 
- (void)mb_insertionSort{ 
    for (int i = 0; i < self.count; i++) { 
        id e = self[i]; 
        int j; 
        for (j = i; j > 0 && self.comparator(self[j - 1],e) == NSOrderedDescending; j--) { 
            [self mb_exchangeWithIndexA:j  indexB:j- 1]; 
        } 
        self[j] = e; 
    } 
}

歸并排序

歸并排序（Merge sort）是建立在歸并操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。

作為一種典型的分而治之思想的算法應用，歸并排序的實現由兩種方法：

>1. 自上而下的遞歸（所有遞歸的方法都可以用迭代重寫，所以就有了第 2 種方法）

>2. 自下而上的迭代；

本文使用的是**自頂向下**的歸并排序

1.算法步驟

1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合并后的序列；

2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置；

3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置；

4. 重復步驟 3 直到某一指針達到序列尾；

5. 將另一序列剩下的所有元素直接復制到合并序列尾。

2.代碼實現

#pragma mark - /**歸并排序 自頂向下*/ 
- (void)mb_mergeSort{ 
    [self mb_mergeSortArray:self LeftIndex:0 rightIndex:(int)self.count - 1]; 
} 
- (void)mb_mergeSortArray:(NSMutableArray *)array LeftIndex:(int )l rightIndex:(int)r{ 
    if(l >= r) return; 
    int mid = (l + r) / 2; 
    [self mb_mergeSortArray:self LeftIndex:l rightIndex:mid]; 
    [self mb_mergeSortArray:self LeftIndex:mid + 1 rightIndex:r]; 
    [self mb_mergeSortArray:self LeftIndex:l midIndex:mid rightIndex:r]; 
} 
- (void)mb_mergeSortArray:(NSMutableArray *)array LeftIndex:(int )l midIndex:(int )mid rightIndex:(int )r{ 
    SEL func = NSSelectorFromString(@"resetSortArray:"); 
    // 開辟新的空間 r-l+1的空間 
    NSMutableArray *aux = [NSMutableArray arrayWithCapacity:r-l+1]; 
    for (int i = l; i  r){// 如果右半部分元素已經全部處理完畢 
            self.comparator(nil, nil); 
            self[k] = aux[i - l]; 
            i++; 
        }else if(self.comparator(aux[i - l], aux[j - l]) == NSOrderedAscending){// 左半部分所指元素 < 右半部分所指元素 
            self[k] = aux[i - l]; 
            i++; 
        }else{ 
            self.comparator(nil, nil); 
            self[k] = aux[j - l]; 
            j++; 
        } 
          
        NSMutableArray *mutArray = [NSMutableArray array]; 
        [self enumerateObjectsUsingBlock:^(MBBarView *  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) { 
            [mutArray addObject:[NSString stringWithFormat:@"%f",obj.frame.size.height]]; 
        }]; 
          
        objc_msgSendSortArray(self.vc,func,mutArray); 
    } 
}

快速排序

快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞狀況下則需要 Ο(n2) 次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他 Ο(nlogn) 算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分為兩個子串行（sub-lists）。

快速排序又是一種分而治之思想在排序算法上的典型應用。本質上來看，快速排序應該算是在冒泡排序基礎上的遞歸分治法。

快速排序的名字起的是簡單粗暴，因為一聽到這個名字你就知道它存在的意義，就是快，而且效率高！它是處理大數據最快的排序算法之一了。

1.算法步驟

1. 從數列中挑出一個元素，稱為 “基準”（pivot）;

2. 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數可以到任一邊）。在這個分區退出之后，該基準就處于數列的中間位置。這個稱為分區（partition）操作；

3. 遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序；

快速排序的優化可考慮當分區間隔小的的時候轉而使用插入排序

2.代碼實現

#pragma mark - /**快速排序*/ 
- (void)mb_quickSort{ 
    //要特別注意邊界的情況 
    [self mb_quickSort:self indexL:0 indexR:(int)self.count - 1]; 
} 
- (void)mb_quickSort:(NSMutableArray *)array indexL:(int)l indexR:(int)r{ 
    if (l >= r) return; 
    int p = [self __partition:array indexL:l indexR:r]; 
    [self mb_quickSort:array indexL:l indexR:p-1]; 
    [self mb_quickSort:array indexL:p + 1 indexR:r]; 
} 
/** 
 對arr[l...r]部分進行partition操作 
 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p] 
   
 @param array array 
 @param l 左 
 @param r 右 
 @return 返回p 
 */ 
- (int)__partition:(NSMutableArray *)array indexL:(int)l indexR:(int)r{ 
    int j = l;// arr[l+1...j] < v ; arr[j+1...i) > v 
    for (int i = l + 1; i <= r ; i++) { 
        if ( self.comparator(array[i], array[ l]) == NSOrderedAscending) { 
            j++; 
            //交換 
            [self mb_exchangeWithIndexA:j indexB:i]; 
        } 
    } 
    self.comparator(nil, nil); 
    [self mb_exchangeWithIndexA:j indexB:l]; 
    return j; 
}

多路快速排序

過多重復鍵值使Quick Sort降至O(n^2)

使用雙快速排序后, 我們的快速排序算法可以輕松的處理包含大量元素的數組

快速排序的優化可考慮當分區間隔小的的時候轉而使用插入排序

1.算法圖示

2.代碼實現

#pragma mark - /**雙路快排*/ 
///使用雙快速排序后, 我們的快速排序算法可以輕松的處理包含大量元素的數組 
- (void)mb_identicalQuickSort{ 
    //要特別注意邊界的情況 
    [self mb_quickSort:self indexL:0 indexR:(int)self.count - 1]; 
} 
- (void)mb_identicalQuickSort:(NSMutableArray *)array indexL:(int)l indexR:(int)r{ 
    if (l >= r) return; 
    int p = [self __partition2:array indexL:l indexR:r]; 
    [self mb_quickSort:array indexL:l indexR:p-1]; 
    [self mb_quickSort:array indexL:p + 1 indexR:r]; 
} 
- (int)__partition2:(NSMutableArray *)array indexL:(int)l indexR:(int)r{ 
    // 隨機在arr[l...r]的范圍中, 選擇一個數值作為標定點pivot 
    [self mb_exchangeWithIndexA:l indexB:(arc4random()%(r-l+1))]; 
    id v = array[l]; 
    // arr[l+1...i) = v 
    int i = l + 1, j = r; 
    while (true) { 
          
        while (i  l + 1 && self.comparator(array[j],v) == NSOrderedDescending) 
            j--; 
          
        if (i > j) { 
            break; 
        } 
        [self mb_exchangeWithIndexA:i indexB:j]; 
          
        i++; 
        j--; 
    } 
    [self mb_exchangeWithIndexA:l indexB:j]; 
    return j; 
}

三路快速排序

對于包含有大量重復數據的數組, 三路快排有巨大的優勢

對于一般性的隨機數組和近乎有序的數組, 三路快排的效率雖然不是***的, 但是是在非常可以接受的范圍里

因此, 在一些語言中, 三路快排是默認的語言庫函數中使用的排序算法。比如Java:)

快速排序的優化可考慮當分區間隔小的的時候轉而使用插入排序

1.算法圖示

2.代碼實現

#pragma mark - /**三路快排*/ 
//對于包含有大量重復數據的數組, 三路快排有巨大的優勢 
- (void)mb_quick3WaysSort{ 
    //要特別注意邊界的情況 
    [self mb_quick3WaysSort:self indexL:0 indexR:(int)self.count - 1]; 
} 
/// 遞歸的三路快速排序算法 
- (void)mb_quick3WaysSort:(NSMutableArray *)array indexL:(int)l indexR:(int)r{ 
    if (l >= r)  return; 
      
    self.comparator(nil, nil); 
    // 隨機在arr[l...r]的范圍中, 選擇一個數值作為標定點pivot 
    [self mb_exchangeWithIndexA:l indexB:(arc4random_uniform(r-l+1) + l)]; 
      
    id v = array[l]; 
      
    int lt = l; // array[l+1...lt] < v 
    int gt = r + 1; // array[gt...r] > v 
    int i = l + 1; // array[lt+1...i) == v 
      
    while (i < gt) { 
        if ( [self compareWithBarOne:array[i] andBarTwo:v] == NSOrderedAscending) { 
            self.comparator(nil, nil); 
            [self mb_exchangeWithIndexA:i indexB:lt + 1]; 
            i++; 
            lt++; 
        }else if  ([self compareWithBarOne:array[i] andBarTwo:v] == NSOrderedDescending){ 
            self.comparator(nil, nil); 
            [self mb_exchangeWithIndexA:i indexB:gt - 1]; 
            gt--; 
        }else{ //array[i] == v 
            i++; 
        } 
    } 
    self.comparator(nil,nil); 
    [self mb_exchangeWithIndexA:l indexB:lt]; 
    [self mb_quick3WaysSort:array indexL:l indexR:lt-1]; 
    [self mb_quick3WaysSort:array indexL:gt indexR:r]; 
      
}

排堆序

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，并同時滿足堆積的性質：即子結點的鍵值或索引總是小于（或者大于）它的父節點。堆排序可以說是一種利用堆的概念來排序的選擇排序。分為兩種方法：

大頂堆：每個節點的值都大于或等于其子節點的值，在堆排序算法中用于升序排列；

小頂堆：每個節點的值都小于或等于其子節點的值，在堆排序算法中用于降序排列；

堆排序的平均時間復雜度為 Ο(nlogn)。

1.算法步驟

1. 創建一個堆 H[0……n-1]；

2. 把堆首（***值）和堆尾互換；

3. 把堆的尺寸縮小 1，并調用 shift_down(1)，目的是把新的數組頂端數據調整到相應位置；

4. 重復步驟 2，直到堆的尺寸為 1

2.代碼實現

///shift_down操作 
- (void)shiftDown:(int )k{ 
    while (2 * k <= _count) { 
        int j = 2 * k; 
        if (j + 1 <= _count && [self heapCompareWithBarOne:_data[j + 1] andBarTwo:_data[j]] == NSOrderedDescending) j++;//左孩子小于右孩子 
        if ([self heapCompareWithBarOne:_data[k] andBarTwo:_data[j]] == NSOrderedDescending) break;//父節點大于子節點 
        self.comparator(nil, nil); 
        [_data mb_exchangeWithIndexA:k indexB:j]; 
        k = j; 
    } 
}

收結與收獲

總結：

在這次重新學習數據結構與算法的過程中筆者充分認識到了學習這些所謂的**基礎知識**的重要性，了解了要想進一步提供iOS開發的水平恰恰不能忽視基礎環節，也恰好在這次學習中用到了圖的深度遍歷解決了在研究埋點過程中找到回溯源的問題。

收獲：

> 1. 基本排序的白板編程

> 2. runtime的添加分類

> 3. runtime的objc_msgSend()

> 4. 深拷貝與淺拷貝

> 5. GCD信號量的使用

如果各位讀者看完有所收獲歡迎在[Github](https://github.com/MisterBooo/Play-With-Sort-OC)上給個star (*^__^*)**

參考與閱讀

* [一本關于排序算法的 GitBook 在線書籍《十大經典排序算法》，使用 JavaScript & Python & Go 實現](https://github.com/hustcc/JS-Sorting-Algorithm)

* [在 JavaScript 中學習數據結構與算法](https://juejin.im/post/594dfe795188250d725a220a)

* [排序動畫](https://github.com/JiongXing/JXSort)

責任編輯：張子龍來源： Cocoa China