- 定义
仅可以在队首进行删除,队尾进行插入的线性表,称为队列。
- 特点
先入队列,则先删除(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")
复制代码