iOS 开发中常用的排序算法原理以及简单实现

在 iOS 开发中，排序算法是基础技能。以下是常用算法的原理说明，并用 Objective-C 和 Swift 实现：

---

1. 冒泡排序（Bubble Sort）

原理：重复遍历数组，比较相邻元素，若顺序错误则交换。每轮遍历将最大值“冒泡”到末尾。

时间复杂度：O(n²)

Objective-C

- (NSArray *)bubbleSort:(NSArray *)array {
    NSMutableArray *mutableArray = [array mutableCopy];
    for (int i = 0; i < mutableArray.count; i++) {
        for (int j = 0; j < mutableArray.count - i - 1; j++) {
            if ([mutableArray[j] intValue] > [mutableArray[j+1] intValue]) {
                [mutableArray exchangeObjectAtIndex:j withObjectAtIndex:j+1];
            }
        }
    }
    return [mutableArray copy];
}

Swift

func bubbleSort(_ array: [Int]) -> [Int] {
    var arr = array
    for i in 0..<arr.count {
        for j in 0..<arr.count - i - 1 {
            if arr[j] > arr[j+1] {
                arr.swapAt(j, j+1)
            }
        }
    }
    return arr
}

---

2. 选择排序（Selection Sort）

原理：每次从未排序部分找到最小值，与未排序部分的第一个元素交换。

时间复杂度：O(n²)

Objective-C

- (NSArray *)selectionSort:(NSArray *)array {
    NSMutableArray *mutableArray = [array mutableCopy];
    for (int i = 0; i < mutableArray.count; i++) {
        NSInteger minIndex = i;
        for (int j = i+1; j < mutableArray.count; j++) {
            if ([mutableArray[j] intValue] < [mutableArray[minIndex] intValue]) {
                minIndex = j;
            }
        }
        [mutableArray exchangeObjectAtIndex:i withObjectAtIndex:minIndex];
    }
    return [mutableArray copy];
}

Swift

func selectionSort(_ array: [Int]) -> [Int] {
    var arr = array
    for i in 0..<arr.count {
        var minIndex = i
        for j in i+1..<arr.count {
            if arr[j] < arr[minIndex] {
                minIndex = j
            }
        }
        arr.swapAt(i, minIndex)
    }
    return arr
}

---

3. 快速排序（Quick Sort）

原理：分治法。选一个基准元素，将数组分为左右两部分（左小右大），递归排序。

时间复杂度：平均 O(n log n)，最差 O(n²)

Objective-C

- (NSArray *)quickSort:(NSArray *)array {
    if (array.count <= 1) return array;
    
    NSInteger pivotIndex = array.count / 2;
    NSNumber *pivot = array[pivotIndex];
    NSMutableArray *less = [NSMutableArray array];
    NSMutableArray *greater = [NSMutableArray array];
    
    for (NSInteger i = 0; i < array.count; i++) {
        if (i == pivotIndex) continue;
        NSNumber *num = array[i];
        if ([num intValue] <= [pivot intValue]) {
            [less addObject:num];
        } else {
            [greater addObject:num];
        }
    }
    
    NSArray *sortedLess = [self quickSort:less];
    NSArray *sortedGreater = [self quickSort:greater];
    return [[sortedLess arrayByAddingObject:pivot] arrayByAddingObjectsFromArray:sortedGreater];
}

Swift

func quickSort(_ array: [Int]) -> [Int] {
    guard array.count > 1 else { return array }
    let pivot = array[array.count/2]
    let less = array.filter { $0 < pivot }
    let equal = array.filter { $0 == pivot }
    let greater = array.filter { $0 > pivot }
    return quickSort(less) + equal + quickSort(greater)
}

---

4. 插入排序（Insertion Sort）

原理：逐个将元素插入已排序部分的正确位置。

时间复杂度：O(n²)

Objective-C

- (NSArray *)insertionSort:(NSArray *)array {
    NSMutableArray *mutableArray = [array mutableCopy];
    for (int i = 1; i < mutableArray.count; i++) {
        NSNumber *key = mutableArray[i];
        int j = i - 1;
        while (j >= 0 && [mutableArray[j] intValue] > [key intValue]) {
            mutableArray[j+1] = mutableArray[j];
            j--;
        }
        mutableArray[j+1] = key;
    }
    return [mutableArray copy];
}

Swift

func insertionSort(_ array: [Int]) -> [Int] {
    var arr = array
    for i in 1..<arr.count {
        let key = arr[i]
        var j = i - 1
        while j >= 0 && arr[j] > key {
            arr[j+1] = arr[j]
            j -= 1
        }
        arr[j+1] = key
    }
    return arr
}

---

5. 希尔排序（Shell Sort）

原理：分组插入排序，逐步减少间隔直到为 1。

时间复杂度：O(n log n)

Objective-C

- (NSArray *)shellSort:(NSArray *)array {
    NSMutableArray *mutableArray = [array mutableCopy];
    NSInteger gap = mutableArray.count / 2;
    while (gap > 0) {
        for (NSInteger i = gap; i < mutableArray.count; i++) {
            NSNumber *temp = mutableArray[i];
            NSInteger j = i;
            while (j >= gap && [mutableArray[j - gap] intValue] > [temp intValue]) {
                mutableArray[j] = mutableArray[j - gap];
                j -= gap;
            }
            mutableArray[j] = temp;
        }
        gap /= 2;
    }
    return [mutableArray copy];
}

Swift

func shellSort(_ array: [Int]) -> [Int] {
    var arr = array
    var gap = arr.count / 2
    while gap > 0 {
        for i in gap..<arr.count {
            let temp = arr[i]
            var j = i
            while j >= gap && arr[j - gap] > temp {
                arr[j] = arr[j - gap]
                j -= gap
            }
            arr[j] = temp
        }
        gap /= 2
    }
    return arr
}

---

6. 归并排序（Merge Sort）

原理：分治法，将数组分成两半递归排序，然后合并有序数组。

时间复杂度：O(n log n)

Objective-C

- (NSArray *)mergeSort:(NSArray *)array {
    if (array.count <= 1) return array;
    
    NSInteger 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 mergeLeft:left right:right];
}

- (NSArray *)mergeLeft:(NSArray *)left right:(NSArray *)right {
    NSMutableArray *result = [NSMutableArray array];
    NSInteger i = 0, j = 0;
    while (i < left.count && j < right.count) {
        if ([left[i] intValue] < [right[j] intValue]) {
            [result addObject:left[i++]];
        } else {
            [result addObject:right[j++]];
        }
    }
    while (i < left.count) [result addObject:left[i++]];
    while (j < right.count) [result addObject:right[j++]];
    return result;
}

Swift

func mergeSort(_ array: [Int]) -> [Int] {
    guard array.count > 1 else { return array }
    let mid = array.count / 2
    let left = mergeSort(Array(array[0..<mid]))
    let right = mergeSort(Array(array[mid...]))
    return merge(left, right)
}

func merge(_ left: [Int], _ right: [Int]) -> [Int] {
    var result = [Int]()
    var i = 0, j = 0
    while i < left.count && j < right.count {
        if left[i] < right[j] {
            result.append(left[i])
            i += 1
        } else {
            result.append(right[j])
            j += 1
        }
    }
    result += Array(left[i...])
    result += Array(right[j...])
    return result
}

---

7. 基数排序（Radix Sort）

原理：按位数从低位到高位依次排序，使用桶排序。

时间复杂度：O(nk)

Objective-C

- (NSArray *)radixSort:(NSArray *)array {
    NSMutableArray *mutableArray = [array mutableCopy];
    NSInteger max = [[mutableArray valueForKeyPath:@"@max.self"] integerValue];
    NSInteger maxDigit = log10(max) + 1;
    
    for (NSInteger digit = 0; digit < maxDigit; digit++) {
        NSMutableArray *buckets = [NSMutableArray arrayWithCapacity:10];
        for (int i = 0; i < 10; i++) {
            [buckets addObject:[NSMutableArray array]];
        }
        for (NSNumber *num in mutableArray) {
            NSInteger bucketIndex = (num.integerValue / (NSInteger)pow(10, digit)) % 10;
            [buckets[bucketIndex] addObject:num];
        }
        [mutableArray removeAllObjects];
        for (NSMutableArray *bucket in buckets) {
            [mutableArray addObjectsFromArray:bucket];
        }
    }
    return [mutableArray copy];
}

Swift

func radixSort(_ array: [Int]) -> [Int] {
    var arr = array
    let max = arr.max() ?? 0
    var maxDigit = Int(log10(Double(max))) + 1
    
    for digit in 0..<maxDigit {
        var buckets: [[Int]] = Array(repeating: [], count: 10)
        for num in arr {
            let index = (num / Int(pow(10, Double(digit)))) % 10
            buckets[index].append(num)
        }
        arr = buckets.flatMap { $0 }
    }
    return arr
}

---

以上是 iOS 开发中常用的排序算法实现。根据数据规模选择合适算法：小数据用插入/冒泡，大数据用快速/归并。