排序算法

常见的排序算法有很多种，以下是一些常见的排序算法及其在 Swift 中的实现示例，不包含可视化图解。

1. 冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法，通过重复遍历列表，比较相邻元素并交换它们，直到没有需要交换的元素为止。

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 bubbleArray = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(&bubbleArray)
print("Bubble Sort: \(bubbleArray)") // 输出排序后的数组

2. 选择排序（Selection Sort）

选择排序每次从未排序的部分选择最小（或最大）的元素，将其放到已排序部分的末尾。

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

var selectionArray = [64, 25, 12, 22, 11]
selectionSort(&selectionArray)
print("Selection Sort: \(selectionArray)") // 输出排序后的数组

3. 插入排序（Insertion Sort）

插入排序通过构建有序序列，将每个新元素插入到已排序序列中的合适位置。

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

var insertionArray = [12, 11, 13, 5, 6]
insertionSort(&insertionArray)
print("Insertion Sort: \(insertionArray)") // 输出排序后的数组

4. 快速排序（Quick Sort）

快速排序是一个分而治之的算法，选择一个“基准”元素，将数组分成两部分，分别递归排序。

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)
}

let quickArray = quickSort([64, 34, 25, 12, 22, 11, 90])
print("Quick Sort: \(quickArray)") // 输出排序后的数组

5. 归并排序（Merge Sort）

归并排序也是一种分而治之的算法，将数组分成两半，分别进行排序，然后合并排序的部分。

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

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

let mergeArray = mergeSort([38, 27, 43, 3, 9, 82, 10])
print("Merge Sort: \(mergeArray)") // 输出排序后的数组

6. 堆排序（Heap Sort）

堆排序利用堆这种数据结构，首先构建最大堆，然后依次将最大元素放到已排序部分。

func heapify(_ array: inout [Int], _ n: Int, _ i: Int) {
    var largest = i
    let left = 2 * i + 1
    let right = 2 * i + 2
    
    if left < n && array[left] > array[largest] {
        largest = left
    }
    if right < n && array[right] > array[largest] {
        largest = right
    }
    if largest != i {
        array.swapAt(i, largest)
        heapify(&array, n, largest)
    }
}

func heapSort(_ array: inout [Int]) {
    let n = array.count
    
    for i in (n / 2 - 1).stride(through: 0, by: -1) {
        heapify(&array, n, i)
    }
    
    for i in (1..<n).reversed() {
        array.swapAt(0, i)
        heapify(&array, i, 0)
    }
}

var heapArray = [12, 11, 13, 5, 6, 7]
heapSort(&heapArray)
print("Heap Sort: \(heapArray)") // 输出排序后的数组

总结

以上是几种常见的排序算法在 Swift 中的实现示例。每种排序算法都有其优缺点，适用的场景也不同。在选择排序算法时，可以根据数据的特性和需求做出相应的选择。