[Swift]归并排序 | Merge sort

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/11075281.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

1、定义

创建在归并操作上的一种有效的排序算法，效率为。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

分治法

(1)、分割：递归地把当前序列平均分割成两半。

(2)、集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

2、算法分析

最坏时间复杂度：

最优时间复杂度：

平均时间复杂度：

最坏空间复杂度：

3、动图展示

(1)、对7个整数值的数组进行归并排序（自上而下）。

(2)、使用归并排序为一列数字进行排序的过程：

(3)、使用归并排序为一列数字进行排序的过程

4、归并操作（merge）

也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

5、归并操作一：递归法（Top-down）

(1)、申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

(2)、设定两个指针，最初位置分别为两个已经排序序列的起始位置

(3)、比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

(4)、重复步骤3直到某一指针到达序列尾

(5)、将另一序列剩下的所有元素直接复制到合并序列尾

//MARK:归并排序(Top-down implementation)
func mergeSort(_ array: [Int]) -> [Int] {
    //1.如果传入数组为空或者只有一个元素，我们就不需要继续拆分，直接返回该传入数组。
    guard array.count > 1 else { return array }
    //2.找出数组个数中间值。
    let middleIndex = array.count / 2
    //3.使用步骤2得到的中间值，不断的拆分左边的数组。
    let leftArray = mergeSort(Array(array[0..<middleIndex]))
    //4.同时不断拆分右边的数组。
    let rightArray = mergeSort(Array(array[middleIndex..<array.count]))
    //5.最后，将所有数组合并到一起，得到排序数组。
    return merge(leftPile: leftArray, rightPile: rightArray)
}
​
//MARK:归并方式一:递归法（Top-down）
func merge(leftPile: [Int], rightPile: [Int]) -> [Int] {
    //1.在合并过程中，你需要创建2个索引来追踪合并的两个数组。
    var leftIndex = 0
    var rightIndex = 0
    //2.这里的空数组为合并数组，在接下来的步骤里，这个空数组会不断地从其它数组放入新元素。
    var orderedPile = [Int]()
    //3.这里的while循环会将左右两侧的数组进行比较，并按照大小放入到orderedPile里。
    while leftIndex < leftPile.count && rightIndex < rightPile.count {
        if leftPile[leftIndex] < rightPile[rightIndex] {
            orderedPile.append(leftPile[leftIndex])
            leftIndex += 1
        } else if leftPile[leftIndex] > rightPile[rightIndex] {
            orderedPile.append(rightPile[rightIndex])
            rightIndex += 1
        } else {
            orderedPile.append(leftPile[leftIndex])
            leftIndex += 1
            orderedPile.append(rightPile[rightIndex])
            rightIndex += 1
        }
    }
    //4.如果执行到步骤4，则证明leftPile和rightPile里的数字均已完全合并到orderedPile里。这时候，我们不需要继续做比较，只需要将剩下的数组合并起来。
    while leftIndex < leftPile.count {
        orderedPile.append(leftPile[leftIndex])
        leftIndex += 1
    }
    
    while rightIndex < rightPile.count {
        orderedPile.append(rightPile[rightIndex])
        rightIndex += 1
    }
    
    return orderedPile
}

测试：

var arr:[Int] = [1,9,2,8,3,7,4,6,5,10,11,12]
print(mergeSort(arr))
//Print [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

5、归并操作二：迭代法（Bottom-up）

原理如下（假设序列共有个元素）：

(1)、将序列每相邻两个数字进行归并操作，形成个序列，排序后每个序(2)、列包含两/一个元素

(3)、若此时序列数不是1个则将上述序列再次归并，形成个序列，每个序列包含四/三个元素

(4)、重复步骤2，直到所有元素排序完毕，即序列数为1

//MARK:归并排序(Bottom-up implementation)
//MARK:归并方式二：迭代法（Bottom-up）
func mergeSort<T>(_ a: [T], _ isOrderedBefore: (T, T) -> Bool) -> [T] {
    let n = a.count
    //1.我们在合并左右两侧的数组时候，不能同时修改它们自身数组的内容，所以我们需要一个临时工作数组来执行这个功能。但是每一次合并过程都重新分配新的临时工作数组是非常浪费资源的，因此，我们使用两个工作数组来代替，并用d来区分它们，数组z[d]是用来读取，z[d-1]用来写，我们称之为双重缓冲。
    var z = [a, a]
    var d = 0
    
    var width = 1
     //2.从概念上来说，这一版本的工作方式和上一个版本的工作方式是相同的。首先，它会合并长度为1的数组，然后是2，然后是4，以此类推。数组的长度是有width决定的。最初的时候它的数值是1，然后在每个循环结束后乘以2。所以外循环决定了需要合并的数组长度，在每一次进入新的循环，需要合并的数组的长度跟着变得更大。
    while width < n {
        
        var i = 0
          //3.内循环是一个合并过程，合并后的数组会被放入z[1 - d]。
        while i < n {
            
            var j = i
            var l = i
            var r = i + width
            
            let lmax = min(l + width, n)
            let rmax = min(r + width, n)
             //4.从逻辑上来说，此版本与上一个版本相同，唯一不同的是，这里我们使用了双重缓冲，所以我们从z[d]上读数值，在z[1-d]写数组。这里的isOrderedBefore函数可以对比各种类型的数据，不仅仅是数字。
            while l < lmax && r < rmax {
                if isOrderedBefore(z[d][l], z[d][r]) {
                    z[1 - d][j] = z[d][l]
                    l += 1
                } else {
                    z[1 - d][j] = z[d][r]
                    r += 1
                }
                j += 1
            }
            while l < lmax {
                z[1 - d][j] = z[d][l]
                j += 1
                l += 1
            }
            while r < rmax {
                z[1 - d][j] = z[d][r]
                j += 1
                r += 1
            }
            
            i += width*2
        }
        
        width *= 2
        //5.此时，z[d]数组已经合并数组大小为为z[1-d]。交换活动数组，以便在下一步中从刚刚创建的新堆中读取数据。
        d = 1 - d
    }
    return z[d]
}

测试：

var arr:[Int] = [1,9,2,8,3,7,4,6,5,10,11,12]
print(mergeSort(arr,>))
//Print [12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]