校对 双端队列

Author: andyRon

Deque/Deque-Optimized.swift

@@ -0,0 +1,80 @@
+/**
+ * 优化的双端队列。
+ * 出队和入队操作都是 O(1)。
+ */
+public struct Deque<T> {
+    private var array: [T?]
+    private var head: Int
+    private var capacity: Int
+    private let originalCapacity: Int
+    
+    public init(_ capacity: Int = 10) {
+        self.capacity = max(capacity, 1)
+        originalCapacity = self.capacity
+        array = [T?](repeating: nil, count: capacity)
+        head = capacity
+    }
+    
+    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 enqueueFront(_ element: T) {
+        if head == 0 {  // 队列前面空白空间耗尽时，需要添加
+            capacity *= 2
+            let emptySpace = [T?](repeating: nil, count: capacity)
+            array.insert(contentsOf: emptySpace, at: 0)
+            head = capacity
+        }
+        
+        head -= 1
+        array[head] = element
+    }
+    
+    public mutating func dequeue() -> T? {
+        guard head < array.count, let element = array[head] else { return nil }
+        
+        array[head] = nil
+        head += 1
+        
+        if capacity >= originalCapacity && head >= capacity*2 { // 清理队列前面有时多于的空白空间
+            let amountToRemove = capacity + capacity/2
+            array.removeFirst(amountToRemove)
+            head -= amountToRemove
+            capacity /= 2
+        }
+        return element
+    }
+    
+    public mutating func dequeueBack() -> T? {
+        if isEmpty {
+            return nil
+        } else {
+            return array.removeLast()
+        }
+    }
+    
+    public func peekFront() -> T? {
+        if isEmpty {
+            return nil
+        } else {
+            return array[head]
+        }
+    }
+    
+    public func peekBack() -> T? {
+        if isEmpty {
+            return nil
+        } else {
+            return array.last!
+        }
+    }
+}

Deque/Deque-Simple.swift

@@ -0,0 +1,47 @@
+
+/**
+ * 简单的双端队列
+ */
+public struct Deque<T> {
+    private 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 enqueueFront(_ element: T) {
+        array.insert(element, at: 0)
+    }
+    
+    public mutating func dequeue() -> T? {
+        if isEmpty {
+            return nil
+        } else {
+            return array.removeFirst()
+        }
+    }
+    
+    public mutating func dequeueBack() -> T? {
+        if isEmpty {
+            return nil
+        } else {
+            return array.removeLast()
+        }
+    }
+    
+    public func peekFront() -> T? {
+        return array.first
+    }
+    
+    public func peakBack() -> T? {
+        return array.last
+    }
+}

Deque/Deque.playground/Contents.swift

@@ -1,30 +1,58 @@
 
-
+/**
+ * 优化的双端队列。
+ * 出队和入队操作都是 O(1)。
+ */
 public struct Deque<T> {
-    private var array = [T]()
+    private var array: [T?]
+    private var head: Int
+    private var capacity: Int
+    private let originalCapacity: Int
+    
+    public init(_ capacity: Int = 10) {
+        self.capacity = max(capacity, 1)
+        originalCapacity = self.capacity
+        array = [T?](repeating: nil, count: capacity)
+        head = capacity
+    }
 
     public var isEmpty: Bool {
-        return array.isEmpty
+        return count == 0
     }
 
     public var count: Int {
-        return array.count
+        return array.count - head
     }
 
     public mutating func enqueue(_ element: T) {
         array.append(element)
     }
 
     public mutating func enqueueFront(_ element: T) {
-        array.insert(element, at: 0)
+        if head == 0 {
+            capacity *= 2
+            let emptySpace = [T?](repeating: nil, count: capacity)
+            array.insert(contentsOf: emptySpace, at: 0)
+            head = capacity
+        }
+        
+        head -= 1
+        array[head] = element
     }
 
     public mutating func dequeue() -> T? {
-        if isEmpty {
-            return nil
-        } else {
-            return array.removeFirst()
+        guard head < array.count, let element = array[head] else { return nil }
+        
+        array[head] = nil
+        head += 1
+        
+        if capacity >= originalCapacity && head >= capacity*2 {
+            let amountToRemove = capacity + capacity/2
+            array.removeFirst(amountToRemove)
+            head -= amountToRemove
+            capacity /= 2
         }
+        return element
     }
 
     public mutating func dequeueBack() -> T? {
@@ -36,10 +64,32 @@ public struct Deque<T> {
     }
 
     public func peekFront() -> T? {
-        return array.first
+        if isEmpty {
+            return nil
+        } else {
+            return array[head]
+        }
     }
 
-    public func peakBack() -> T? {
-        return array.last
+    public func peekBack() -> T? {
+        if isEmpty {
+            return nil
+        } else {
+            return array.last!
+        }
     }
 }
+
+
+var deque = Deque<Int>()
+deque.enqueue(1)
+deque.enqueue(2)
+deque.enqueue(3)
+deque.enqueue(4)
+
+deque.dequeue()       // 1
+deque.dequeueBack()   // 4
+
+deque.enqueueFront(5) // deque: [5, 2, 3]
+
+deque.dequeue()       // 5