隊列像一個列表，您只能在最后插入新元素，并從最前面刪除元素。 這確保了您第一個入隊的元素也是您出隊的第一個元素。 先來后到！

為什么需要這個？ 好吧，在許多算法中，您希望在某個時間點將對象添加到臨時列表，然后再次將其從此列表中刪除。 通常，添加和刪除這些對象的順序很重要。

隊列是先進先出的順序。 您首先插入的元素也是第一個出隊列的元素。 這只是公平！ （一個非常相似的數據結構，棧，是后入先出。）

例如，讓我們向隊列添加一個數字：

queue.enqueue(10)

隊列現在是[10]。 將下一個數字添加到隊列：

queue.enqueue(3)

隊列現在是[10，3]。 再添加一個數字：

queue.enqueue(57)

隊列現在是[10，3，57]。 讓我們讓隊列第一個元素出列：

queue.dequeue()

這里返回10，因為這是我們插入的第一個數字。 隊列現在是[3，57]。 每個元素的索引都向前移動了1。

queue.dequeue()

這返回3，下一個出列返回57，依此類推。 如果隊列為空，則dequeue返回nil，或者在一些實現中提示出錯誤信息。

注意: 隊列并不總是最好的選擇。 如果項目從列表中添加和刪除的順序不重要，您可以使用棧而不是隊列。 棧更簡單，更快。

代碼

這是一個在Swift中非常簡單的隊列實現。 它只是一個數組的包裝，可以讓你入列，出列和查看最前面的元素：

public struct Queue<T> {
    fileprivate var array = [T]()
    
    public var isEmpty: Bool {
        return array.isEmpty
    }
    
    public var count: Int {
        return array.count
    }
    
    public mutating func enqueue(_ element: T) {
        array.append(element)
    }
    
    public mutating func dequeue() -> T? {
        if isEmpty {
            return nil
        } else {
            return array.removeFirst()
        }
    }
    
    public func peek() -> T? {
        return array.first
    }
}

這個隊列實現了功能，但它不是最佳的。

入隊是一個O（1）操作，因為添加到數組的末尾總是需要相同的時間量，而不管數組的大小。 這是最好的。

你可能想知道為什么將數據附加到數組是O（1），或者說是一個常量時間的操作。 這是因為Swift中的數組在結尾總是有一些空間。 如果我們做如下操作：

var queue = Queue<String()
queue.enqueue("Ada")
queue.enqueue("Steve")
queue.enqueue("Tim")

那么數組看起來像這樣：

[ "Ada", "Steve", "Tim", xxx, xxx, xxx ]

其中xxx是保留但尚未填充的內存。 向陣列中添加新元素將覆蓋下一個未使用的內存：

[ "Ada", "Steve", "Tim", "Grace", xxx, xxx ]

這只是將存儲器從一個地方復制到另一個地方，即常量時間操作。

當然，在陣列的末端只有有限數量的這種未使用的內存。 當最后一個xxx被使用，并且您想要添加另一個元素，數組需要調整大小，以騰出更多的空間。

數組要調整大小，需要創建心數組，分配新的內存空間，把現有數組的數據復制到新數組中。這是一個O（n）操作，相對比較慢。但他只是每隔一段時間發生一次，因此將新元素添加到數組末尾的平均時間是O（1）。

出列的操作則不同。要出列，我們要刪除數組開頭的元素，而不是結尾。這總是一個O（n）操作，因為剩余的元素要在數組中向前移動一位。

在示例中，第一個元素“Ada”出列，“Steve”替換為“Ada”，“Tim”替換為“Steve”，“Grace”替換為“Tim”：

出列前   [ "Ada", "Steve", "Tim", "Grace", xxx, xxx ]
                   /       /      /
                  /       /      /
                 /       /      /
                /       /      /
 出列后   [ "Steve", "Tim", "Grace", xxx, xxx, xxx ]

在內存中移動移動所有元素總是O（n）操作。所以我們剛剛簡單的實現隊列，入列是高效的，但出列還有待改進...

一個更高效的隊列

為了使出列更高效，我們可以使用同樣的技巧，在數組前面保留一些額外的可用空間。 我們不得不自己編寫這個代碼，因為內置的Swift數組不支持這種功能。

思路是這樣的：當我們將一個元素出列時，我們不會移動數組的其他元素，而是將出列的位置標記為空。在“Ada”出列之后，數組是：

[ xxx, "Steve", "Tim", "Grace", xxx, xxx ]

在“Steve”出列之后，數組是：

[ xxx, xxx, "Tim", "Grace", xxx, xxx ]

這些空的內存永遠不會被使用，是對空間的浪費。每隔一段時間，你可以將剩余的元素向前移動：

[ "Tim", "Grace", xxx, xxx, xxx, xxx ]

這樣在內存中移動元素的過程是O（n）操作。但它很少發生，所以平均時間是O（n）。

新的隊列代碼：

public struct Queue<T> {
    fileprivate var array = [T?]()
    fileprivate var head = 0
    
    public var isEmpty: Bool {
        return count == 0
    }
    
    public var count: Int {
        return array.count - head
    }
    
    public mutating func enqueue(_ element: T) {
        array.append(element)
    }
    
    public mutating func dequeue() -> T? {
        guard head < array.count, let element = array[head] else {
            return nil
        }
        
        array[head] = nil
        head += 1
        
        let percentage = Double(head) / Double(array.count)
        if array.count > 50 && percentage > 0.25 {
            array.removeFirst(head)
            head = 0
        }
        
        return element
    }
    
    public func peek() ->T? {
        if isEmpty {
            return nil
        } else {
            return array[head]
        }
    }
}

現在數組中存儲的是可選類型T?，而不是T，因為我們要標記數組元素為空。head變量是空元素的索引。

大多數的新代碼在dequeue()中。一個元素出列時，首先將array[head]的值設為nil，達到從數組中刪除改元素的目的。然后我們讓head+1，使下一個元素會在隊列的最前面。

出列前：

[ "Ada", "Steve", "Tim", "Grace", xxx, xxx ]
  head

出列后:

[ xxx, "Steve", "Tim", "Grace", xxx, xxx ]
        head

這就像一個奇怪的收銀臺：人們排隊結賬但不向收銀臺走過去，而是收銀臺移動。

當然，如果我們從來沒有刪除隊列前面那些空的部分，我們不斷的入列和出列元素，那么對列將繼續增長。因此，要定期修剪數組，我們執行以下操作：

let percentage = Double(head) / Double(array.count)
    if array.count > 50 && percentage > 0.25 {
        array.removeFirst(head)
        head = 0
    }

如果空白的長度站到整個數組的25%以上，我們就把空白的部分去掉。但是如果數組元素數量不多，我們也不想一直修剪它。所以至少有50個元素才會去修剪它。

注意: 這只是一個例子，你需要根據你應用的實際情況來決定什么情況下修剪數組。

在playground里測試，代碼：

var q = Queue<String>()
q.array                   // [] empty array

q.enqueue("Ada")
q.enqueue("Steve")
q.enqueue("Tim")
q.array             // [{Some "Ada"}, {Some "Steve"}, {Some "Tim"}]
q.count             // 3

q.dequeue()         // "Ada"
q.array             // [nil, {Some "Steve"}, {Some "Tim"}]
q.count             // 2

q.dequeue()         // "Steve"
q.array             // [nil, nil, {Some "Tim"}]
q.count             // 1

q.enqueue("Grace")
q.array             // [nil, nil, {Some "Tim"}, {Some "Grace"}]
q.count             // 2

測試修剪數組，把這行代碼：

    if array.count > 50 && percentage > 0.25 {

替換為這行代碼：

    if head > 2 {

你再出隊一個對象，數組就是這樣的：

q.dequeue()         // "Tim"
q.array             // [{Some "Grace"}]
q.count             // 1

隊列前面的nil對象被刪除，不再浪費空間。 新版本的隊列比第一個更復雜，但是出隊也是一個O（1）操作，因為我們對于如何使用數組有了更多的理解。

作者：Matthijs Hollemans -- Swift算法俱樂部

原文鏈接：
https://github.com/raywenderlich/swift-algorithm-club/tree/master/Queue