Queue(队列)-Swift实现与广度优先搜索应用-CSDN博客

定义

仅可以在队首进行删除，队尾进行插入的线性表，称为队列。

特点

先入队列，则先删除（First In First Out），类似Stack

应用

键盘的输入输出

广度优先搜索等算法的实现

Swift的实现（普通）

struct Queue<T> {
   //这里可以用链表代替
    private var array = Array<T>()

    //判空
    var isEmpty: Bool {
        return array.isEmpty
    }
    //队列中元素个数
    var count: Int {
        return array.count
    }
    //查看队首元素
    var front: T? {
        return array.first
    }
    //入队
    mutating func enqueque(_ element: T) {
        array.append(element)
    }
    //出队
    mutating func dequeue() -> T? {
        guard !isEmpty else { return nil }
        return array.removeFirst()
    }
}
复制代码

现在实现的这个队列就可以工作了，但是还有些地方是不太完美的。

1.当enqueue(入队)操作时，因为是将新的元素加到数组的尾部，所以入队的时间复杂对为O(1)。原因：在Swift中，在数组的后面，会预留出一些空的位置

var queue = Queue<String>()
queue.enqueque("a")
queue.enqueque("b")
queue.enqueque("c")
//实际在数组中情况为
["a", "b", "c", **,  **, **]
//** 就是预留出来的内存，以备将来插入新的元素
queue.enqueque("d") 后
// 实际情况为
["a", "b", "c", "d",  **, **]
复制代码

Array的这种机制也会有问题，因为在数组的末端只会预留少量的位置，当最后一个预留的位置也被插入新的元素后，就需要将整个数组中的元素一起拷贝，到一个新的拥有更多位置的数组中，这时的时间复杂度为O(n)，但是这种情况只是偶尔发生，所以平均的时间复杂对还是O(1)。

2.当dequeue(出队)操作时，因为是将数组中的第一个元素删除，当删除第一个元素后，数组中剩余的所有元素都需要向前移动一个位置，来填充前面的空白，所以这个时候的时间复杂度为O(n)，每当dequeue一次后，时间复杂度都为O(n)，这种操作效率是很低的。
Swift的实现（稍高效）稍稍高效些的队列的实现办法有好几种，比如循环队列等，我们介绍一个比循环队列实现简单些的。
思路：不再是每出队一次，就将数组中的元素向前移动，而是等到满足一定条件后，才统一的向前移动。
代码

struct Queue<T> {
    private var array = Array<T?>()
    ///用来标记队列的头位置
    private var headIndex = 0
    //判空
    var isEmpty: Bool {
        return array.isEmpty
    }
    
    //队列中元素个数
    var count: Int {
        return array.count
    }
    
    //查看队首元素
    var front: T? {
        if isEmpty { return nil }
        return array[headIndex]
    }
    
    //入队
    mutating func enqueque(_ element: T) {
        array.append(element)
    }
    
    //出队
    mutating func dequeue() -> T? {
        //存在队首元素
        guard !isEmpty, let firstElement = array[headIndex] else { return nil }
        array[headIndex] = nil
        
        //重新标记队首的位置
        headIndex += 1
        //达到条件，删除前面的空位置，条件可以按照需要进行更改
        let percentage = Double(headIndex)/Double(array.count)
        if array.count > 20 && percentage > 0.25 {
            array.removeFirst(headIndex)
            headIndex = 0
        }
        return firstElement
    }
}
复制代码

广度优先搜索
寻找大兵瑞恩，从下面的人物关系图中，最终找到瑞恩的最短路径
思路 -- 先找你直接认识的朋友中，是否有瑞恩，有查找完成 -- 如果在你直接认识的朋友中没有，则在朋友的朋友中查找，直到找到，或所有人都找过 -- 关键，只有你直接认识的朋友中找完后，才能去从朋友的朋友中去查找，这就需要通过队列的先进先出特性来实现 -- 记录查找过的人，防止循环查找

//通过字典(散列)来记录整张关系图
    var relationGraph: [String: [String]] = {
        var dic: [String: [String]] = ["Me": ["A", "C"]]
        dic["A"] = ["B"]
        dic["C"] = ["B", "D", "Ryan"]
        dic["B"] = ["Ryan"]
        dic["D"] = ["Ryan"]
        return dic
    }()
    //创建一个存储，朋友及朋友的朋友的队列
    var queue = Queue<String>()
    //用来记录已经查询过的人
    var checked = [String]()

    func find(_ name: String) {
        findFromQueue(name)
    }

    //到朋友队列中找Ryan
    func findFromQueue(_ name: String) {
        while queue.count > 0 {
            guard let person = queue.dequeue() else {
                return print("Can not find \(name)")
            }
            //如果查过则找下一个
            if checked.contains(person) { continue }
            //记录已经查询过的
            checked.append(person)
            //找到
            if person == name {
                print("Find \(name)")
                break
            //未找到
            }else {
                //将朋友的朋友加入到队列中
                enQueueFriends(person)
            }
        }
    }
    //将朋友加入到队列中
    func enQueueFriends(_ name: String) {
        guard let friends = relationGraph[name] else { return }
        let _ = friends.map {
            return queue.enqueque($0)
        }
    }
复制代码

调用

//将自己的朋友加入到待查找队列中
enQueueFriends("Me")
//从自己的朋友及朋友的朋友中寻找Ryan
find("Ryan")
复制代码