- 选择排序

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

1.算法步骤

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

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

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

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.算法步骤

a. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。

b. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

c. 针对所有的元素重复以上的步骤,除了最后一个。

d. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

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.算法步骤

a. 将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。

b. 从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)

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.算法步骤

a. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;

b. 设定两个指针,最初位置分别为两个已经排序序列的起始位置;

c. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;

d. 重复步骤 3 直到某一指针达到序列尾;

e. 将另一序列剩下的所有元素直接复制到合并序列尾。

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.算法步骤

a. 从数列中挑出一个元素,称为 “基准”(pivot);

b. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;

c. 递归地(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;
}

总结与收获

在这次学习的数据结构与算法中,重新认识到”基础知识”的重要性,想要更进一步地了解进阶IOS的水平,不凡在这些基础上下功夫,也通过这次学习追溯到算法的本源。