[Swift]八大排序算法（七）：归并排序

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

排序分为内部排序和外部排序。

内部排序：是指待排序列完全存放在内存中所进行的排序过程，适合不太大的元素序列。

外部排序：指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。

当N小于20的时候，插入排序具有最好的性能。

当N大于20时，快速排序具有最好的性能，尽管归并排序(merge sort)和堆排序(heap sort)复杂度都为nlog2(n)。

---

 归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

算法描述

归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾，将另一序列剩下的所有元素直接复制到合并序列尾

---

ViewController.swift文件：运行时间（7.7611s）

import UIKit

class ViewController: UIViewController {
    //属性1:用来存储需要排序的数组
    var result : Array<Int> = Array<Int>()
     //属性2:排序时使用到的临时二维数组
    var tempArray: Array<Array<Int>> = []
    //属性3:统计排序花费的时间
    var date : Date!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        //初始化一个整形数组
        var array : Array<Int> = Array<Int>()
        //将1至100的100个整数，存入到该数组中
        for i in 1...100
        {
            array.append(i)
        }
        //添加一个循环语句，
        //用来生成一个由100个随机整数组成的数组
        for _ in 1...100
        {
            //首先根据数组的长度，
            //获得一个1至100的随机整数
            let temp = Int(arc4random() % UInt32(array.count))+1
            //根据随机值从数组中获得指定位置的整数，
            //并存储在用来排序的数组中
            let num = array[temp-1]
            result.append(num)
            //从原数组中移该随机数，以避免获得重复的数字
            array.remove(at: temp-1)
        }
        //添加一个循环语句，
        //用来生成100个自定义视图对象
        for i in 1...100
        {
            //初始化自定义视图对象
            let num = result[i-1]
            //并设置它的显示区域。
            //其中视图的高度，是当前数组中的数字的两倍大小
            let view = SortView(frame: CGRect(x: 10+i*3, y: 200, width: 2, height: num * 2))
            view.backgroundColor = .black
            //设置视图的标识值
            view.tag = i
            //并将视图添加到当前视图控制器的根视图
            self.view.addSubview(view)
        }
        //然后添加一个按钮
        //当用户点击该按钮时对数组进行排序
        let bt = UIButton(frame: CGRect(x: 10, y: 340, width: 300, height: 40))
        //设置背景按钮的背景颜色为橙色
        bt.backgroundColor = .orange
        //设置按钮在正常状态下的标题文字
        bt.setTitle("Sort", for: .normal)
        //给按钮对象绑定点击事件，
        bt.addTarget(self, action: #selector(reOrderView), for: .touchUpInside)
        //将按钮添加到当前视图控制器的根视图
        self.view.addSubview(bt)
    }
    
    //添加一个方法，用来响应按钮的点击事件
    @objc func reOrderView()
    {
        //获得当前的日期和时间
        date = Date()
        //在一个全局队列中，以异步的方式对数组进行排序
        //并实时调整和数组中的数值相对应的视图的位置
        DispatchQueue.global().async
        {
            //调用实例方法，用来进行可视化的插入排序。
            //该方法在下方的代码中实现
            self.sort(items: self.result)
            //获得排序后的系统时间，
            //并在控制台输出两个时间的差值，
            //从而获得排序所花费的大致时间。
            //考虑线程休眠的影响，此数据仅做参考
            let endDate = Date()
            print(endDate.timeIntervalSince(self.date))
        }
    }

    //添加一个方法，用来实现具体的可视化的归并排序的功能
    func sort(items: Array<Int>)
    {
        //首先清除临时数组中的所有元素
        tempArray.removeAll()
        //然后通过一个循环语句，
        //将需要排序的数组中的每一个元素，
        //都转换为包含一元素的数组，
        //并将该数组添加到临时数组中
        for item in items
        {
            var subArray: Array<Int> = []
            subArray.append(item)
            tempArray.append(subArray)
        }
        //接着对临时数组进行归并排序操作，
        //直到它的长度为1
        while tempArray.count != 1
        {
            var i = 0
            while i < tempArray.count - 1
            {
                //将每两个左右相邻的子数组进行合并，
                //(合并之后又在子数组中进行了排序，合并的方法将在下方的代码中实现)
                //合并后的结果存入左侧的子数组中，
                //右侧的子数组则在合并之后，从临时数组中删除
                tempArray[i] = mergeArray(firstList: tempArray[i], secondList: tempArray[i + 1])
                tempArray.remove(at: i + 1)
                //然后对合并后的子数组进行遍历，
                //用来及时更新在合并和排序之后的每个子数组中的元素所对应的视图的高度
                for subIndex in 0..<tempArray[i].count
                {
                    //通过实例方法，对子数组中的元素所对应的视图的高度进行更新，
                    //此方法在下方代码中实现
                    let index = self.countSubItemIndex(endIndex: i, subItemIndex: subIndex)
                    self.udpateView(j: index, height: tempArray[i][subIndex])
                }
                //接着将索引值递增，直到循环结束
                i = i + 1
            }
        }
    }

    //添加一个方法，
    //用来实现两个相邻子数组的的合并，以及合并之后排序
    func mergeArray(firstList: Array<Int>, secondList: Array<Int>) -> Array<Int>
    {
        //变量1：用于存储排序后的数组
        var resultList: Array<Int> = []
        //变量2:用于辅助排序
        var firstIndex = 0
        //变量3:用于辅助排序
        var secondIndex = 0
        //添加一个循环语句
        //用来对两个数组中的元素进行比较
        while firstIndex < firstList.count && secondIndex < secondList.count
        {
            //如果第一个数组中的元素，小于第二个数组中的元素，
            //则将较小值添加到结果数组中
            if firstList[firstIndex] < secondList[secondIndex]
            {
                resultList.append(firstList[firstIndex])
                firstIndex += 1
            }
            else
            {
                //否则将第二个数组中的较小的值，
                //添加到结果数组中
                resultList.append(secondList[secondIndex])
                secondIndex += 1
            }
        }
        //然后将第一个数组中的剩余元素，
        //追加到结果数组中
        while firstIndex < firstList.count
        {
            resultList.append(firstList[firstIndex])
            firstIndex += 1
        }
        //同样将第二个数组中的剩余元素，追加到结果数组中
        while secondIndex < secondList.count
        {
            resultList.append(secondList[secondIndex])
            secondIndex += 1
        }
        //最后返回合并并且排序后的数组
        return resultList
    }

    //添加一个方法
    //用来计算并返回位于合并后的子数组中的元素的索引位置
    func countSubItemIndex(endIndex: Int, subItemIndex: Int) -> Int
    {
        //定义一个整形变量，
        //用来统计需要计算索引位置的元素之前的数组大小。
        var sum = 0
        //累加当前元素之前的所有数组的长度之和
        for i in 0..<endIndex
        {
            sum += tempArray[i].count
        }
        //然后加上元素在其自身数组中的索引位置，
        //就获得了元素在整个二维数组中的索引位置
        return sum + subItemIndex
    }
    
    //添加一个方法，用来更新视图的高度
    func udpateView(j: Int, height: Int)
    {
        //由于需要对界面元素进行调整，
        //所以需要切换至主线程
        weak var weak_self = self
        DispatchQueue.main.async
        {
            //根据标识值，
            //获得和需要交换顺序的数组元素相对应的视图对象
            //并设置它的新的高度
            let view = weak_self?.view.viewWithTag(j+1)
            view?.frame.size.height = CGFloat(height*2)
        }
        //使线程休眠0.01秒，
        //以方便观察排序的视觉效果
        Thread.sleep(forTimeInterval: 0.01)
    }
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
}

SortView.swift文件

import UIKit

class SortView: UIView {
    //首先重写父类的初始化方法
    override init(frame: CGRect)
    {
        //设置自定义视图对象的显示区域
        super.init(frame: frame)
        self.frame = frame
    }

    //添加一个必须实现的初始化方法
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    //重写父类的重新布局子视图方法
    //将在此视图中对视图进行外观设置
    override func layoutSubviews()
    {
        //首先获得自定义视图在界面中对Y轴坐标
        let y: CGFloat = 300 - frame.height
        //然后重新设置自定义视图的位置
        self.frame = frame
        self.frame.origin.y = y
        //根据自定义视图的高度，计算一个权重数值
        //用于生成不同的背景颜色
        let weight = frame.height / 200
        //生成不同y色相的颜色对象，从而给自定义视图设置不同的背景颜色
        //然后打开ViewController.swift文件
        let color = UIColor(hue: weight, saturation: 1, brightness: 1, alpha: 1)
        self.backgroundColor = color
    }
    /*
    // Only override draw() if you perform custom drawing.
    // An empty implementation adversely affects performance during animation.
    override func draw(_ rect: CGRect) {
        // Drawing code
    }
    */
}