排序算法知识点

时间 2019-11-30

标签排序算法知识繁體版

原文原文链接

测试算法性能（准备工做）

排序执行前NSDate * startDate = [NSDate date];，排序结束后return [[NSDate date] timeIntervalSinceDate:startDate];//返回排序算法运行时间
判断某个数组是不是一个有序数组

- (BOOL)testSort:(NSMutableArray* )array length:(NSInteger) len
{
    // 非严格升序
    int IsSortAscending = [array[0] integerValue] <= [array[len-1] integerValue] ? 1 : -1;
    int i;
    for (i = 1; i < len - 1; ++i)
    {
        if (IsSortAscending * ([array[i] integerValue] - [array[i+1] integerValue]) > 0)
            return NO;
    }
    
    return YES;
}
复制代码

生成一个乱序的随机数据长度的数组

/**
 *
 *  @param startIndex 开始数字
 *  @param length     数字的长度
 *  @return 返回一个随机的不重复的数组
 */
- (NSMutableArray*) GetRandomWithStartIndex:(NSInteger) startIndex andLength:(NSInteger) length
{
    NSInteger endIndex = startIndex+length;//结束数字
    NSMutableArray *arr = [NSMutableArray arrayWithCapacity:length];//返回的结果（随机数数组）
    NSMutableArray *arr1 = [NSMutableArray arrayWithCapacity:length];//填充随机数的数组
    for (NSInteger i = startIndex; i<endIndex; i++) {//填充随机数的全部可能值
        [arr1 addObject:[NSString stringWithFormat:@"%ld",(long)i]];
    }
    for (NSInteger i=startIndex; i<endIndex; i++) {
        NSInteger index = arc4random()%arr1.count;//这个随机数在当初初始化随机数数组中的随机位置
        NSInteger radom = [arr1[index] intValue];//随机位置对应的随机值
        NSNumber *num = [NSNumber numberWithInteger:radom];
        [arr addObject:num];
        [arr1 removeObjectAtIndex:index];//添加以后 就把基本的填充的数组的参数删除这个
    }
    return arr;
}
复制代码

最后打印NSLog(@"sortUse = %f s-----------",(float)timeUse);排序时间，NSLog(@"isSort = %d -------------",isSort);是否有序。

选择排序（O（n*n））

思想:
假设10个元素的数组，从小到大进行排序，首先在整个数组范围内选择出最小的数，和首位交换(首位已经排好序)；以后再在首位之后剩下的元素中找最小的数，和尚未排序的第一个位置交换位置，以此类推。算法

-(float)selectionSort:(NSMutableArray *)arr andCount:(NSInteger)n{
    NSDate * startDate = [NSDate date];//计算代码运行时间
    for (int i = 0; i < n; i ++) {
        //寻找 (i,n)里的最小值
        int minIndex = i;
        for (int j = i+1 ; j < n ; j ++) {//选择出i~n中最小的值的index
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        [arr exchangeObjectAtIndex:i withObjectAtIndex:minIndex];//最小值与i交换，而后继续比较其余没有排序的数
    }
    return [[NSDate date] timeIntervalSinceDate:startDate];//返回排序算法运行时间
}
复制代码

插入排序（O（n*n））

思想:
假设10个元素数组，第一个元素不动；第二个元素和第一个元素比较，如符合排序条件就插入到第一个元素前面；第三个元素和第二个元素比较，如符合排序条件就插入到第二个元素前面，第三个元素再和第一个元素比较，如符合排序条件就插入到第一个元素前面，不符合终止这次内层循环；以此类推。数组

- (float)insertionSort:(NSMutableArray *)arr andCount:(NSInteger)n{
    NSDate * startDate = [NSDate date];
    
    for (NSInteger i = 1; i < n; i ++ ) {//对于插入排序，第0个元素不用考虑
        //寻找元素arr[i]合适的插入位置
        for (NSInteger j = i; j > 0; j -- ) {//当前位置元素和前面位置元素比较，最多到j = 1;
            if (arr[j] < arr[j-1]) {
                [arr exchangeObjectAtIndex:j withObjectAtIndex:j-1];
            }else
                break;
        }
        
    }
    return [[NSDate date] timeIntervalSinceDate:startDate];
}
复制代码

插入排序法的改进

插入排序能够提早终止第二层循环，但有时效率仍是会慢于选择排序。目前的插入排序的版本在遍历的同时也在不停的交换，交换是比单纯的遍历仍是耗时的，每一次交换都有赋值和访问索引时间。改进，让每一次遍历只执行一次交换。遍历比较以后，不马上进行交换，如知足排序要求，把当前的元素赋值一个副本，直接赋值过去到相应的位置。bash

//改进后的插入排序
- (float)insertionSort2:(NSMutableArray *)arr andCount:(NSInteger)n{
    NSDate * startDate = [NSDate date];

    for (NSInteger i = 1; i < n; i ++ ) {//对于插入排序，第0个元素不用考虑
        //寻找元素arr[i]合适的插入位置
        NSNumber * temp = arr[i];
        NSInteger j;
        for (j = i; j > 0; j -- ) {//当前位置元素和前面位置元素比较，最多到j = 1;
            if (temp < arr[j-1]) {
                arr[j] = arr[j-1];
            }else
                break;
        }
        arr[j] = temp;
    }
    
    return [[NSDate date] timeIntervalSinceDate:startDate];
}
复制代码

冒泡排序

水中的气泡越往上冒，气泡就越大，因此用这个现象来描述冒泡排序。假设数组中有杂乱无序的数字：拿第一个数字和其余全部数字进行比较，若比它大则交换位置，直到将这些数字中最大的数交换到最上面。针对除以前比较轮已经排好序的其余全部元素重复以上的步骤。每一轮j都从0开始，当i轮排序，就有最后面的i个数字是排好的，因此后面的每轮都不用理他了，也就是arr.count-1-i。dom

- (float)bubbleSort:(NSMutableArray *)arr{
    NSDate * startDate = [NSDate date];//计算代码运行时间
    NSInteger i = 0;
    NSInteger j = 0;
    NSNumber * temp;
    
    for (i = 0; i< arr.count-1; i++) {
        for ( j = 0;j<arr.count-1-i ; j++) {
            if (arr[j]<arr[j+1]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    return [[NSDate date] timeIntervalSinceDate:startDate];//返回排序算法运行时间
}
复制代码

冒泡排序的优化

第一种优化方式:
设置一个标记位来标记内层循环是否发生了交换，若是没有发生交换，说明已是有序的了，就提早结束循环。

/*
 * 冒泡排序优化一
 * 设置一个标记来标志一趟比较是否发生交换
 * 若是没有发生交换，则数组已经有序
 * */
- (float)bubbleSort2:(NSMutableArray *)arr{
    NSDate * startDate = [NSDate date];//计算代码运行时间
    NSInteger i = 0;
    NSInteger j = 0;
    NSNumber * temp;
    int flag = 0;
    
    for (i = 0; i< arr.count-1; i++) {
        for ( j = 0;j<arr.count-1-i ; j++) {
            if (arr[j]<arr[j+1]) {
                flag = 1;
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        if (flag == 0) {
            break;
        }
    }
    return [[NSDate date] timeIntervalSinceDate:startDate];//返回排序算法运行时间
}
复制代码

第二种优化方式：记录最后发生交换的位置，做为下一趟比较结束的位置。

快速排序

堆排序

堆排序的改进

奇偶排序

将数组中的元素排列为奇数在前偶数在后。处理策略是定义front，end。并令其初始指向数组头节点和尾节点。front从前日后找应该放在尾部的偶数节点，end从后往前找应该放在头部的奇数节点，若front位于end以前则交换两者内容，不然结束处理过程。性能

- (void)oddEvenSort:(NSMutableArray *)arr  andCount:(NSInteger)n{
    
    if (n<= 0) {
        return;
    }
    NSInteger front = 0;
    NSInteger end = n-1;
    while (front<end) {
        while (front<n && ([arr[front] integerValue]&1)==1) {// 从前日后找偶数
            front++;
        }
        while (end>0 && ([arr[end] integerValue]&1)==0) {//从后往前找奇数
            end--;
        }
        if (front<end) {
            NSNumber * num = arr[front];
            arr[front] = arr[end];
            arr[end] = num;
        }
    }
}
复制代码