在Object-C中学习数据结构与算法之排序算法

作者 : 开心源码 本文共7525个字,预计阅读时间需要19分钟 发布时间: 2022-05-11 共61人阅读

笔者在学习数据结构与算法时,尝试着将排序算法以动画的形式呈现出来更加方便了解记忆,本文配合Demo 在Object-C中学习数据结构与算法之排序算法阅读更佳。

目录

  • 选择排序
  • 冒泡排序
  • 插入排序
  • 快速排序
  • 双路快速排序
  • 三路快速排序
  • 堆排序
  • 总结与收获
  • 参考与阅读

选择排序

选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n2) 的时间复杂度。所以使用到它的时候,数据规模越小越好。唯一的好处可可以就是不占使用额外的内存空间了吧。

1.算法步骤

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

  2. 再从剩余未排序元素中继续寻觅最小(大)元素,而后放到已排序序列的末尾。

  3. 重复第二步,直到所有元素均排序完毕。

2.动画演示

3.代码实现

#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.动画演示

3.代码实现

#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.动画演示

3.代码实现

#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.动画演示

3.代码实现

#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; i++) {        // aux 中索引 i-l 的对象 与 array 中索引 i 的对象一致        aux[i-l] = self[i];    }    // 初始化,i指向左半部分的起始索引位置l;j指向右半部分起始索引位置mid+1    int i = l, j = mid + 1;    for ( int k = l; k <= r; k++) {        if (i > mid) { // 假如左半部分元素已经一律解决完毕            self.comparator(nil, nil);            self[k] = aux[j - l];            j++;        }else if(j > 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.动画演示

3.代码实现

#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.动画演示

3.代码实现

#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; arr(j...r] >= v    int i = l + 1, j = r;    while (true) {                while (i <= r && self.comparator(array[i],v) == NSOrderedAscending)            i++;                while (j > 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.动画演示

3.代码实现

#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.动画演示

3.代码实现

///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上给个star 谢谢各位

参考与阅读

  • 一本关于排序算法的 GitBook 在线书籍 《十大经典排序算法》,用 JavaScript & Python & Go 实现
  • 在 JavaScript 中学习数据结构与算法
  • 排序动画

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 在Object-C中学习数据结构与算法之排序算法

发表回复