swift算法之排序：（零）排序算法总结

1、排序算法总结

 

 

2、排序算法的时间复杂度比较

常用的时间复杂度大小为

O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

3、稳定性算法

什么是稳定性？

答：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri = rj，且ri 在 rj之前，而在排序后的序列中，ri仍在rj前，则称算法是稳定的，反之是不稳定的

常见的算法主要有：冒泡、选择、插入、快排、堆排、希尔、桶等

1）稳定算法：冒泡、插入、归并、基数、桶

2）不稳定算法：选择、快排、堆排、希尔

这些算法会在后续文章中一一讲解

 

4、排序算法的封装及调用

1）自定义一个协议

//自定义排序协议
protocol SortType {
    func sort(_ items : Array<Int>)->Array<Int>
}

2）所有排序类遵守协议，并实现协议方法

//冒泡排序
class BubbleSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("冒泡排序")
        var list = items
        if list.count > 0 {
            list = SortSummary.bubbleSort(list)
            //list = SortSummary.bubbleSort1(list)
            //list = SortSummary.bubbleSort2(list)
        }
        return list
    }
}

//插入排序
class InsertSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("插入排序")
        var list = items
        if list.count > 0 {
            list = SortSummary.insertSort(list)
            //list = SortSummary.insertSort1(list)
            //list = SortSummary.insertSort1(list)
            //list = SortSummary.insertSort3(list, <)
        }
        return list
    }
}

//选择排序
//插入排序
class ChooseSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("选择排序")
        var list = items
        if list.count > 0 {
            list = SortSummary.chooseSort(list)
        }
        return list
    }
}

//堆排序
class HeapSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("堆排序")
        var list = items
        if list.count > 0 {
            SortSummary.heapSort(&list)
        }
        return list
    }
}

//归并排序
class MergeSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("归并排序")
        var list = items
        if list.count > 0 {
            list = SortSummary.mergeSort(list)
            //list = SortSummary.mergeSortBottomUp(list, <)
        }
        return list
    }
}

//快速排序
class QuickSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("快速排序")
        var list = items
        if list.count > 0 {
            SortSummary.quickSort(&list, 0, items.count-1)
        }
        return list
    }
}

//希尔排序
class ShellSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("希尔排序")
        var list = items
        if list.count > 0 {
            SortSummary.shellSort(&list)
        }
        return list
    }
}

//桶排序
class BucketSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("桶排序")
        var list = items
        let max = maxNum(list)
        if list.count > 0 {
            list = SortSummary.bucketSort(list, max)
        }
        return list
    }
    
    private func maxNum(_ list : Array<Int>)->Int{
        var max = list[0]
        for i in list {
            if i > max {
                max = i
            }
        }
        return max+1
    }
}


//基数排序
class RadixSort:SortType{
    func sort(_ items: Array<Int>) -> Array<Int> {
        print("基数排序")
        var list = items
        if list.count > 0 {
            SortSummary.radixSort(&list)
        }
        return list
    }
    
}

3）调用

func sortClassTest(){
       commonSort(BubbleSort())
        commonSort(InsertSort())
        commonSort(ChooseSort())
        commonSort(HeapSort())
        commonSort(MergeSort())
        commonSort(QuickSort())
        commonSort(ShellSort())
        commonSort(BucketSort())
        commonSort(RadixSort())
    }
    private func commonSort(_ sortObject : SortType){
        let list : Array<Int> = [62, 88, 58, 47, 62, 35, 73, 51, 99, 37, 93]
        let sortList = sortObject.sort(list)
        print(sortList)
        print("\n")
    }

具体的排序代码 见github项目中的 SortClass.swift 和 SortSummary.swift，调用在ViewController.swift类中

5、排序实战

描述：已知有很多会议，如果有这些会议时间有重叠，则将它们合并。

例：有一个会议的时间为3点到5点，另一个会议时间为4点到6点，那么合并之后的会议时间为3点到6点

 

思想：遍历一次数组，然后归并所有重叠时间，将数组按照会议开始的时间排序

具体实现：

1）定义会议类

//定义会议的类
public class MeetingTime{
    //会议开始时间
    public var start : Int
    //会议结束时间
    public var end : Int
    
    //初始化
    public init(_ start : Int, _ end : Int){
        self.start = start
        self.end = end
    }
}

2）排序实现

func meetingTimeMerge(_ meetingTimes : [MeetingTime])->[MeetingTime]{
        var meetingTimes = meetingTimes
       //处理特殊情况
        guard meetingTimes.count > 1 else {
            return meetingTimes
        }
        
        //排序
        var meetingSort = meetingTimes.sort(){
            if $0.start != $1.start {
                return $0.start < $1.start
            }else{
                return $0.end < $1.end
            }
        }
        
        //新建结果数组
        var res = [MeetingTime]()
        res.append(meetingTimes[0])
        
        //遍历排序后的数组，并与结果数组归并
        for i in 1..<meetingTimes.count {
            let last = res[res.count-1]
            let current = meetingTimes[i]
            if current.start > last.end {
                res.append(current)
            }else{
                last.end = max(last.end, current.end)
            }
        }
        return res
    }
}

3）调用

var array10 = [MeetingTime.init(1, 3), MeetingTime.init(5, 6), MeetingTime.init(4, 7), MeetingTime.init(2, 3)]
array10 = SortSummary.meetingTimeMerge(array10)
 for i in array10 {
     print(i.start,i.end,"\n")
 }

运行结果：

1 3 
4 7