在Object-C中學習數據結構與算法之排序算法

時間  2019-12-09
標籤 object 學習 數據 結構 算法 排序算法 欄目 C&C++ 简体版
原文   原文鏈接

筆者在學習數據結構與算法時，嘗試着將排序算法以動畫的形式呈現出來更加方便理解記憶，本文配合Demo 在Object-C中學習數據結構與算法之排序算法閱讀更佳。git

目錄

  • 選擇排序
  • 冒泡排序
  • 插入排序
  • 快速排序
  • 雙路快速排序
  • 三路快速排序
  • 堆排序
  • 總結與收穫
  • 參考與閱讀

選擇排序

選擇排序是一種簡單直觀的排序算法，不管什麼數據進去都是 O(n²) 的時間複雜度。因此用到它的時候，數據規模越小越好。惟一的好處可能就是不佔用額外的內存空間了吧。github

1.算法步驟

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

  2. 再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。數組

  3. 重複第二步，直到全部元素均排序完畢。數據結構

2.動畫演示

3.代碼實現

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

冒泡排序

冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，若是他們的順序錯誤就把他們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。架構

1.算法步驟

  1. 比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。app

  2. 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。這步作完後，最後的元素會是最大的數。dom

  3. 針對全部的元素重複以上的步驟，除了最後一個。ide

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

2.動畫演示

3.代碼實現

 1#pragma mark - /**冒泡排序*/
 2- (void)mb_bubbleSort{
 3    bool swapped;
 4    do {
 5        swapped = false;
 6        for (int i = 1; i < self.count; i++) {
 7            if (self.comparator(self[i - 1],self[i]) == NSOrderedDescending) {
 8                swapped = true;
 9                [self mb_exchangeWithIndexA:i  indexB:i- 1];
10            }
11        }
12    } while (swapped);
13}

插入排序

插入排序的代碼實現雖然沒有冒泡排序和選擇排序那麼簡單粗暴，但它的原理應該是最容易理解的了，由於只要打過撲克牌的人都應該可以秒懂。插入排序是一種最簡單直觀的排序算法，它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。

1.算法步驟

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

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

2.動畫演示

3.代碼實現

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

歸併排序

歸併排序（Merge sort）是創建在歸併操做上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個很是典型的應用。

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

  1. 自上而下的遞歸（全部遞歸的方法均可以用迭代重寫，因此就有了第 2 種方法）
  2. 自下而上的迭代；

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

1.算法步驟

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

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

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

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

  5. 將另外一序列剩下的全部元素直接複製到合併序列尾。

2.動畫演示

3.代碼實現

 1#pragma mark - /**歸併排序 自頂向下*/
 2- (void)mb_mergeSort{
 3    [self mb_mergeSortArray:self LeftIndex:0 rightIndex:(int)self.count - 1];
 4}
 5- (void)mb_mergeSortArray:(NSMutableArray *)array LeftIndex:(int )l rightIndex:(int)r{
 6    if(l >= r) return;
 7    int mid = (l + r) / 2;
 8    [self mb_mergeSortArray:self LeftIndex:l rightIndex:mid];
 9    [self mb_mergeSortArray:self LeftIndex:mid + 1 rightIndex:r];
10    [self mb_mergeSortArray:self LeftIndex:l midIndex:mid rightIndex:r];
11}
12
13- (void)mb_mergeSortArray:(NSMutableArray *)array LeftIndex:(int )l midIndex:(int )mid rightIndex:(int )r{
14
15    SEL func = NSSelectorFromString(@"resetSortArray:");
16    // 開闢新的空間 r-l+1的空間
17    NSMutableArray *aux = [NSMutableArray arrayWithCapacity:r-l+1];
18    for (int i = l; i <= r; i++) {
19        // aux 中索引 i-l 的對象 與 array 中索引 i 的對象一致
20        aux[i-l] = self[i];
21    }
22    // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
23    int i = l, j = mid + 1;
24    for ( int k = l; k <= r; k++) {
25        if (i > mid) { // 若是左半部分元素已經所有處理完畢
26            self.comparator(nil, nil);
27            self[k] = aux[j - l];
28            j++;
29        }else if(j > r){// 若是右半部分元素已經所有處理完畢
30            self.comparator(nil, nil);
31            self[k] = aux[i - l];
32            i++;
33        }else if(self.comparator(aux[i - l], aux[j - l]) == NSOrderedAscending){// 左半部分所指元素 < 右半部分所指元素
34            self[k] = aux[i - l];
35            i++;
36        }else{
37            self.comparator(nil, nil);
38            self[k] = aux[j - l];
39            j++;
40        }
41
42        NSMutableArray *mutArray = [NSMutableArray array];
43        [self enumerateObjectsUsingBlock:^(MBBarView *  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
44            [mutArray addObject:[NSString stringWithFormat:@"%f",obj.frame.size.height]];
45        }];
46
47        objc_msgSendSortArray(self.vc,func,mutArray);
48    }
49
50}

快速排序

快速排序是由東尼·霍爾所發展的一種排序算法。在平均情況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞情況下則須要 Ο(n2) 次比較，但這種情況並不常見。事實上，快速排序一般明顯比其餘 Ο(nlogn) 算法更快，由於它的內部循環（inner loop）能夠在大部分的架構上頗有效率地被實現出來。

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

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

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

1.算法步驟

  1. 從數列中挑出一個元素，稱爲 「基準」（pivot）;

  2. 從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區退出以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做；

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

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

2.動畫演示

3.代碼實現

 1#pragma mark - /**快速排序*/
 2- (void)mb_quickSort{
 3    //要特別注意邊界的狀況
 4    [self mb_quickSort:self indexL:0 indexR:(int)self.count - 1];
 5}
 6- (void)mb_quickSort:(NSMutableArray *)array indexL:(int)l indexR:(int)r{
 7    if (l >= r) return;
 8    int p = [self __partition:array indexL:l indexR:r];
 9    [self mb_quickSort:array indexL:l indexR:p-1];
10    [self mb_quickSort:array indexL:p + 1 indexR:r];
11}
12/**
13 對arr[l...r]部分進行partition操做
14 返回p, 使得arr[l...p-1] < arr[p] ; arr[p+1...r] > arr[p]
15
16 @param array array
17 @param l 左
18 @param r 右
19 @return 返回p
20 */
21- (int)__partition:(NSMutableArray *)array indexL:(int)l indexR:(int)r{
22    int j = l;// arr[l+1...j] < v ; arr[j+1...i) > v
23    for (int i = l + 1; i <= r ; i++) {
24        if ( self.comparator(array[i], array[ l]) == NSOrderedAscending) {
25            j++;
26            //交換
27            [self mb_exchangeWithIndexA:j indexB:i];
28        }
29    }
30    self.comparator(nil, nil);
31    [self mb_exchangeWithIndexA:j indexB:l];
32    return j;
33}

雙路快速排序

過多重複鍵值使Quick Sort降至O(n^2)
使用雙快速排序後, 咱們的快速排序算法能夠輕鬆的處理包含大量元素的數組
快速排序的優化可考慮當分區間隔小的的時候轉而使用插入排序

1.算法圖示

2.動畫演示

3.代碼實現

 1#pragma mark - /**雙路快排*/
 2///使用雙快速排序後, 咱們的快速排序算法能夠輕鬆的處理包含大量元素的數組
 3- (void)mb_identicalQuickSort{
 4    //要特別注意邊界的狀況
 5    [self mb_quickSort:self indexL:0 indexR:(int)self.count - 1];
 6}
 7- (void)mb_identicalQuickSort:(NSMutableArray *)array indexL:(int)l indexR:(int)r{
 8    if (l >= r) return;
 9    int p = [self __partition2:array indexL:l indexR:r];
10    [self mb_quickSort:array indexL:l indexR:p-1];
11    [self mb_quickSort:array indexL:p + 1 indexR:r];
12}
13- (int)__partition2:(NSMutableArray *)array indexL:(int)l indexR:(int)r{
14    // 隨機在arr[l...r]的範圍中, 選擇一個數值做爲標定點pivot
15    [self mb_exchangeWithIndexA:l indexB:(arc4random()%(r-l+1))];
16    id v = array[l];
17    // arr[l+1...i) <= v; arr(j...r] >= v
18    int i = l + 1, j = r;
19    while (true) {
20
21        while (i <= r && self.comparator(array[i],v) == NSOrderedAscending)
22            i++;
23
24        while (j > l + 1 && self.comparator(array[j],v) == NSOrderedDescending)
25            j--;
26
27        if (i > j) {
28            break;
29        }
30        [self mb_exchangeWithIndexA:i indexB:j];
31
32        i++;
33        j--;
34    }
35    [self mb_exchangeWithIndexA:l indexB:j];
36
37    return j;
38}

三路快速排序

對於包含有大量重複數據的數組, 三路快排有巨大的優點
對於通常性的隨機數組和近乎有序的數組, 三路快排的效率雖然不是最優的, 可是是在很是能夠接受的範圍裏
所以, 在一些語言中, 三路快排是默認的語言庫函數中使用的排序算法。好比Java:)

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

1.算法圖示

2.動畫演示

3.代碼實現

 1#pragma mark - /**三路快排*/
 2//對於包含有大量重複數據的數組, 三路快排有巨大的優點
 3- (void)mb_quick3WaysSort{
 4    //要特別注意邊界的狀況
 5    [self mb_quick3WaysSort:self indexL:0 indexR:(int)self.count - 1];
 6}
 7/// 遞歸的三路快速排序算法
 8- (void)mb_quick3WaysSort:(NSMutableArray *)array indexL:(int)l indexR:(int)r{
 9
10    if (l >= r)  return;
11
12    self.comparator(nil, nil);
13    // 隨機在arr[l...r]的範圍中, 選擇一個數值做爲標定點pivot
14    [self mb_exchangeWithIndexA:l indexB:(arc4random_uniform(r-l+1) + l)];
15
16    id v = array[l];
17
18    int lt = l; // array[l+1...lt] < v
19    int gt = r + 1; // array[gt...r] > v
20    int i = l + 1; // array[lt+1...i) == v
21
22    while (i < gt) {
23        if ( [self compareWithBarOne:array[i] andBarTwo:v] == NSOrderedAscending) {
24            self.comparator(nil, nil);
25            [self mb_exchangeWithIndexA:i indexB:lt + 1];
26
27            i++;
28            lt++;
29        }else if  ([self compareWithBarOne:array[i] andBarTwo:v] == NSOrderedDescending){
30            self.comparator(nil, nil);
31            [self mb_exchangeWithIndexA:i indexB:gt - 1];
32            gt--;
33        }else{ //array[i] == v
34            i++;
35        }
36
37    }
38    self.comparator(nil,nil);
39    [self mb_exchangeWithIndexA:l indexB:lt];
40
41    [self mb_quick3WaysSort:array indexL:l indexR:lt-1];
42    [self mb_quick3WaysSort:array indexL:gt indexR:r];
43
44}

堆排序

堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似徹底二叉樹的結構，並同時知足堆積的性質：即子結點的鍵值或索引老是小於（或者大於）它的父節點。堆排序能夠說是一種利用堆的概念來排序的選擇排序。分爲兩種方法：

大頂堆：每一個節點的值都大於或等於其子節點的值，在堆排序算法中用於升序排列；
小頂堆：每一個節點的值都小於或等於其子節點的值，在堆排序算法中用於降序排列；
堆排序的平均時間複雜度爲 Ο(nlogn)。

1.算法步驟

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

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

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

  4. 重複步驟 2，直到堆的尺寸爲 1

2.動畫演示

3.代碼實現

 1///shift_down操做
 2- (void)shiftDown:(int )k{
 3    while (2 * k <= _count) {
 4        int j = 2 * k;
 5        if (j + 1 <= _count && [self heapCompareWithBarOne:_data[j + 1] andBarTwo:_data[j]] == NSOrderedDescending) j++;//左孩子小於右孩子
 6        if ([self heapCompareWithBarOne:_data[k] andBarTwo:_data[j]] == NSOrderedDescending) break;//父節點大於子節點
 7        self.comparator(nil, nil);
 8        [_data mb_exchangeWithIndexA:k indexB:j];
 9        k = j;
10    }
11}

若是各位讀者看完有所收穫歡迎在Github上給個star 謝謝各位

參考與閱讀

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程