[Swift]八大排序算法（三）：选择排序 和 简单选择排序

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

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

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

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

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

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

---

选择排序：

是对冒泡排序法 的一种改进。冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。

原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。

也即，每一趟在n-i+1(i=1，2，…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。

简单选择排序:

第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；

第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；

以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

---

选择排序：

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

import UIKit

//对数组类型进行扩展
extension Array
{
    //扩展方法：用来交换数组中的两个位置的元素
    fileprivate mutating func swap(i:Int,j:Int)
    {
        //通过一个临时变量，交换数组中的两个不同位置的元素
        let temp = self[i]
        self[i] = self[j]
        self[j] = temp
    }
}

//对具有可比较性的数组进行扩展
//以实现选择排序功能
extension Array where Element:Comparable
{
    //添加一个方法，用来实现具体的排序功能
    //使用mutating关键字修饰方法，
    //是为了能在方法内部修改自身变量的值
    mutating func selectorSort() {
        //定义一个整形变量
        //用来存储数组中的最小值所在的索引位置
        var min = 0
        //添加一个循环语句，用来获取数组中的最小值
        for i in 0..<self.count-1
        {
            //将当前的索引值赋予临时变量
            min = i
            //添加另一个循环语句，
            for j in i+1...self.count-1
            {
                //假如第二个循环遍历到的元素的值小于之前确定的最小值，
                //则更改临时变量中的索引值，
                //如此就在一次循环中获得了最小值在数组中的索引位置
                if self[j] < self[min]
                {
                    min = j
                }
            }
            //将该最小值的索引位置和外部循环的索引值进行比较，
            //如果两者不相等，表示找到了新的最小位置，
            //并交换两者的位置
            if min != i
            {
                swap(i: min, j: i)
            }
        }
    }
}

class ViewController: UIViewController {
    //上面是选择排序算法的编写。
    //现在通过可视化的方式，使用冒泡排序算法
    
    //属性1:用来存储需要排序的数组
    var result : Array<Int> = Array<Int>()
    //属性2:统计排序花费的时间
    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,  2, height: num * 2))
            view.backgroundColor = .black
            //设置视图的标识值
            view.tag = i
            //并将视图添加到当前视图控制器的根视图
            self.view.addSubview(view)
        }
        //然后添加一个按钮
        //当用户点击该按钮时对数组进行排序
        let bt = UIButton(frame: CGRect(x: 10, y: 340,  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.selectorSort()
            //获得排序后的系统时间，
            //并在控制台输出两个时间的差值，
            //从而获得排序所花费的大致时间。
            //考虑线程休眠的影响，此数据仅做参考
            let endDate = Date()
            print(endDate.timeIntervalSince(self.date))
        }
    }

    //添加一个方法，用来实现具体的可视化的功能
    func selectorSort()
    {
         //下面的代码，是对上方的选择排序代码的拷贝：
        //定义一个整形变量，
        //用来存储数组中的最小值所在的索引位置
        var min = 0
        //添加一个循环语句，用来获取数组中的最小值
        for i in 0..<self.result.count-1
        {
            min = i
            //添加另一个循环语句，
            for j in i+1...self.result.count-1
            {
                //假如第二个循环遍历到的元素的值小于之前确定的最小值，
                //则更改临时变量中的索引值，
                //如此就在一次循环中获得了最小值在数组中的索引位置
                if self.result[j] < self.result[min]
                {
                    min = j
                }
            }
            //将该最小值的索引位置和外部循环的索引值进行比较，
            //如果两者不相等，表示找到了新的最小位置，
            //并交换两者的位置
            if min != i
            {
                //由于需要对界面元素进行调整，
                //所以需要切换至主线程
                weak var weak_self = self
                DispatchQueue.main.async
                {
                    //根据标识值，
                    //获得和需要交换顺序的数组元素相对应的视图对象
                    let view1 = weak_self?.view.viewWithTag(i+1)
                    let view2 = weak_self?.view.viewWithTag(min+1)
                     //获得两个视图对象的水平坐标X的值
                    let posX1 = view1?.frame.origin.x
                    let posX2 = view2?.frame.origin.x
                    //然后交换两个视图对象的水平坐标的值
                    //从而实现两个视图对象的位置的交
                    view1?.frame.origin.x = posX2!
                    view2?.frame.origin.x = posX1!
                    //记得更换两个视图对象的标识值
                    view1?.tag = min+1
                    view2?.tag = i+1
                    //交换数组中两个元素的位置，
                    //从而实现了数据和界面的同步更新
                    self.result.swap(i: min, j: i)
                }
                //使线程休眠0.01秒，
                //以方便观察排序的视觉效果
                Thread.sleep(forTimeInterval: 0.01)
            }
        }
    }
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
}

简单选择排序:

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

import UIKit

extension Array
{
    fileprivate mutating func swap(i:Int,j:Int)
    {
        let temp = self[i]
        self[i] = self[j]
        self[j] = temp
    }
}

extension Array where Element:Comparable
{
    mutating func selectorSort() {
        
        var min = 0
        
        for i in 0..<self.count-1
        {
            min = i
            
            for j in i+1...self.count-1
            {
                if self[j] < self[min]
                {
                    min = j
                }
            }
            
            if min != i
            {
                swap(i: min, j: i)
            }
        }
    }
}


class ViewController: UIViewController {
    
    var result : Array<Int> = Array<Int>()
    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>()
        
        for i in 1...100
        {
            array.append(i)
        }
        
        for _ in 1...100
        {
            let temp = Int(arc4random() % UInt32(array.count))+1
            let num = array[temp-1]
            result.append(num)
            
            array.remove(at: temp-1)
        }
        
        for i in 1...100
        {
            let num = result[i-1]
            let view = SortView(frame: CGRect(x: 10+i*3, y: 200,  2, height: num * 2))
            view.backgroundColor = .black
            view.tag = i
            self.view.addSubview(view)
        }
        
        let bt = UIButton(frame: CGRect(x: 10, y: 340,  300, height: 40))
        bt.backgroundColor = .orange
        bt.setTitle("Sort", for: .normal)
        bt.addTarget(self, action: #selector(reOrderView), for: .touchUpInside)
        self.view.addSubview(bt)
        
        //self.result.selectorSort()
        //print(self.result)
    }
    
    @objc func reOrderView()
    {
        date = Date()
        DispatchQueue.global().async
        {
            self.selectorSort()
            
            let endDate = Date()
            print(endDate.timeIntervalSince(self.date))
        }
    }
    
    func selectorSort()
    {
        //print("简单选择排序")
        var list = self.result
        for i in 0..<list.count
        {
            //print("第(i+1)轮选择，选择下标的范围为(i)----(list.count)")
            var j = i + 1
            var minValue = list[i]
            var minIndex = i
            
            //寻找无序部分中的最小值
            while j < list.count
            {
                if minValue > list[j]
                {
                    minValue = list[j]
                    minIndex = j
                }
                self.udpateView(j: j, height: list[j])
                j = j + 1
            }
            //print("在后半部分乱序数列中，最小值为：(minValue), 下标为：(minIndex)")
            //与无序表中的第一个值交换，让其成为有序表中的最后一个值
            if minIndex != i
            {
                //print("(minValue)与(list[i])交换")
                let temp = list[i]
                list[i] = list[minIndex]
                list[minIndex] = temp
                
                self.udpateView(j: i, height: list[i])
                self.udpateView(j: minIndex, height: list[minIndex])
            }
            //print("本轮结果为：(list)
")
        }
    }
    
    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)
                
        }
        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
    }
    */
}