Swift:在合并排序中计算交换

func mergeSort(_ array: [Int]) -> ([Int], Int) {
    guard array.count > 1 else {
        return (array, 0)
    }
    
    let middleIndex = array.count / 2
    let leftArray = Array(array[..<middleIndex])
    let rightArray = Array(array[middleIndex...])
    
    let (sortedLeftArray, leftCount) = mergeSort(leftArray)
    let (sortedRightArray, rightCount) = mergeSort(rightArray)
    
    let (mergedArray, mergeCount) = merge(sortedLeftArray, sortedRightArray)
    
    return (mergedArray, leftCount + rightCount + mergeCount)
}

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

let array = [5, 2, 6, 1]
let (sortedArray, swapCount) = mergeSort(array)
print("Sorted Array: \(sortedArray)")
print("Swap Count: \(swapCount)")