Objective-C语言的排序算法-优快云博客

本文链接：https://blog.youkuaiyun.com/2501_90990397/article/details/146145328

Objective-C中的排序算法详解

引言

在计算机科学中，排序算法是一类极为重要的算法。它们的作用是将一组数据按照某种顺序排列，通常是从小到大或者从大到小。排序不仅是基础算法之一，也是实际应用中的常见需求。在iOS应用开发中，排序算法也被广泛使用。本文将深入探讨Objective-C中的常用排序算法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序，分析其算法原理，以及在实际开发中的应用。

一、冒泡排序

1.1 算法原理

冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，依次比较相邻的元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有相邻元素需要交换，也就是说该数列已经排序完成。

1.2 实现代码

```objective-c - (NSArray )bubbleSort:(NSArray )array { NSMutableArray *sortedArray = [array mutableCopy]; NSUInteger count = [sortedArray count];

for (NSUInteger i = 0; i < count - 1; i++) {
    for (NSUInteger j = 0; j < count - 1 - i; j++) {
        if (sortedArray[j] > sortedArray[j + 1]) {
            [sortedArray exchangeObjectAtIndex:j withObjectAtIndex:j + 1];
        }
    }
}
return [sortedArray copy];

} ```

1.3 时间复杂度

冒泡排序的时间复杂度为O(n^2)，其中n是数据的数量。在最坏和平均情况下，算法需要进行n*(n-1)/2次比较和交换。在最好情况下（当数据已经是有序的），时间复杂度为O(n)。

二、选择排序

2.1 算法原理

选择排序是一种简单直观的排序算法。它的基本思想是：首先找到数组中最小的元素，将它放在数组的起始位置；然后，再从剩余的元素中寻找最小值，放到已排序的序列的末尾。这个过程持续进行，直到所有元素都被排序。

2.2 实现代码

```objective-c - (NSArray )selectionSort:(NSArray )array { NSMutableArray *sortedArray = [array mutableCopy]; NSUInteger count = [sortedArray count];

for (NSUInteger i = 0; i < count - 1; i++) {
    NSUInteger minIndex = i;
    for (NSUInteger j = i + 1; j < count; j++) {
        if (sortedArray[j] < sortedArray[minIndex]) {
            minIndex = j;
        }
    }
    // 交换
    if (minIndex != i) {
        [sortedArray exchangeObjectAtIndex:i withObjectAtIndex:minIndex];
    }
}
return [sortedArray copy];

} ```

2.3 时间复杂度

选择排序的时间复杂度同样为O(n^2)。无论最佳、最坏或平均情况，比较次数始终是n*(n-1)/2。

三、插入排序

3.1 算法原理

插入排序是一种简单直观的排序算法。它的基本思想是将一个数据插入到已排好序的序列中，从而得到一个新的、包含n+1个元素的有序序列。具体来说，插入排序的过程可以分为两个部分：已排序区间和未排序区间。

3.2 实现代码

```objective-c - (NSArray )insertionSort:(NSArray )array { NSMutableArray *sortedArray = [array mutableCopy]; NSUInteger count = [sortedArray count];

for (NSUInteger i = 1; i < count; i++) {
    id key = sortedArray[i];
    NSUInteger j = i;

    while (j > 0 && [sortedArray[j - 1] compare:key] == NSOrderedDescending) {
        sortedArray[j] = sortedArray[j - 1];
        j--;
    }
    sortedArray[j] = key;
}
return [sortedArray copy];

} ```

3.3 时间复杂度

插入排序的时间复杂度为O(n^2)（最坏和平均情况），但是在最佳情况下（当数据基本有序时），时间复杂度为O(n)。这是因为在最佳情况下，内层循环不会执行。

四、快速排序

4.1 算法原理

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将待排序的数据分成两个部分，一部分的所有数据都比另一部分的所有数据小，随后再按此方法对这两部分数据分别进行快速排序，整个过程可递归进行。

4.2 实现代码

```objective-c - (NSArray )quickSort:(NSArray )array { if (array.count < 2) { return array; }

id pivot = array[array.count / 2]; // 选择基准值
NSMutableArray *less = [NSMutableArray array];
NSMutableArray *equal = [NSMutableArray array];
NSMutableArray *greater = [NSMutableArray array];

for (id num in array) {
    if ([num compare:pivot] == NSOrderedAscending) {
        [less addObject:num];
    } else if ([num compare:pivot] == NSOrderedSame) {
        [equal addObject:num];
    } else {
        [greater addObject:num];
    }
}

return [[self quickSort:less] arrayByAddingObjectsFromArray:equal
        + [self quickSort:greater]];

} ```

4.3 时间复杂度

快速排序的平均时间复杂度为O(n log n)，最坏情况（当数据基本有序时）时间复杂度为O(n^2)。不过，快速排序的实际运行时间通常很快，常用的排序函数往往使用快速排序。

五、归并排序

5.1 算法原理

归并排序是一种分治法（Divide and Conquer）的典型应用。它的基本思想是将数组分成两个子数组，分别对这两个子数组进行归并排序，然后将已排序的子数组合并成一个最终的排序数组。

5.2 实现代码

```objective-c - (NSArray )mergeSort:(NSArray )array { if (array.count < 2) { return array; }

NSUInteger mid = array.count / 2;
NSArray *left = [self mergeSort:[array subarrayWithRange:NSMakeRange(0, mid)]];
NSArray *right = [self mergeSort:[array subarrayWithRange:NSMakeRange(mid, array.count - mid)]];

return [self merge:left right:right];

}

(NSArray )merge:(NSArray )left right:(NSArray )right { NSMutableArray result = [NSMutableArray array]; NSUInteger leftIndex = 0; NSUInteger rightIndex = 0;

while (leftIndex < left.count && rightIndex < right.count) { if ([left[leftIndex] compare:right[rightIndex]] == NSOrderedAscending) { [result addObject:left[leftIndex]]; leftIndex++; } else { [result addObject:right[rightIndex]]; rightIndex++; } }

while (leftIndex < left.count) { [result addObject:left[leftIndex]]; leftIndex++; } while (rightIndex < right.count) { [result addObject:right[rightIndex]]; rightIndex++; }

return result; } ```