Swift 实现冒泡排序

在 Swift 中，实现冒泡排序可以通过使用循环比较相邻元素并交换顺序，直到整个数组变为有序。以下是冒泡排序的基本实现及其优化版本。

基本实现

冒泡排序的基本思路是：从数组的第一个元素开始，比较相邻的两个元素。如果第一个元素比第二个元素大，就交换它们的位置。这样，一轮下来最大的元素会被“冒泡”到数组的末尾。重复这一过程，直到数组完全有序。

func bubbleSort(_ array: inout [Int]) {
    let n = array.count
    for i in 0..<n {
        for j in 0..<n - i - 1 {
            if array[j] > array[j + 1] {
                // 交换相邻元素
                array.swapAt(j, j + 1)
            }
        }
    }
}

使用示例:

var numbers = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(&numbers)
print(numbers) // 输出: [11, 12, 22, 25, 34, 64, 90]

优化版本

基本的冒泡排序在每一轮中都会遍历整个未排序部分的数组，即使数组已经部分有序。为了提高效率，我们可以引入一个标记（swapped），如果在一轮中没有发生任何交换，说明数组已经有序，可以提前结束排序。

func optimizedBubbleSort(_ array: inout [Int]) {
    let n = array.count
    var swapped: Bool

    for i in 0..<n {
        swapped = false
        for j in 0..<n - i - 1 {
            if array[j] > array[j + 1] {
                array.swapAt(j, j + 1)
                swapped = true
            }
        }
        // 如果没有交换，数组已经有序，提前退出
        if !swapped {
            break
        }
    }
}

使用示例

var numbers = [64, 34, 25, 12, 22, 11, 90]
optimizedBubbleSort(&numbers)
print(numbers) // 输出: [11, 12, 22, 25, 34, 64, 90]

冒泡排序的复杂度如下：

• 时间复杂度：最差和平均情况为O(n²)，当数组已经有序时，优化版本的最佳情况可以达到 O(n)。
• 空间复杂度：O(1)，因为排序是原地进行的，不需要额外的内存空间。

需要注意的是：冒泡排序适合于需要简单实现的小规模数组排序，但在处理大量数据时效率较低。