Small tweaks to stack and queue playgrounds

Author: hollance

Queue/Queue.playground/Contents.swift

@@ -1,57 +1,60 @@
 /*
+  Queue
 
-Queue
-
-A queue is a list where you can only insert new items at the back and remove items from the front. This ensures that the first item you enqueue is also the first item you dequeue. First come, first serve!
-
-A queue gives you a FIFO or first-in, first-out order. The element you inserted first is also the first one to come out again. It's only fair! (A very similar data structure, the stack, is LIFO or last-in first-out.)
-
-Insertion - O(1)
-Deletion - O(n)
+  A queue is a list where you can only insert new items at the back and 
+  remove items from the front. This ensures that the first item you enqueue
+  is also the first item you dequeue. First come, first serve!
 
+  A queue gives you a FIFO or first-in, first-out order. The element you
+  inserted first is also the first one to come out again. It's only fair!
 
+  In this implementation, enqueuing is an O(1) operation, dequeuing is O(n).
 */
 
-
-import UIKit
-
-
 public struct Queue<T> {
-    private var array = [T]()
-    
-    public var count: Int {
-        return array.count
-    }
-    
-    public var isEmpty: Bool {
-        return array.isEmpty
-    }
-    
-    public mutating func enqueue(element: T) {
-        array.append(element)
-    }
-    
-    public mutating func dequeue() -> T? {
-        if count == 0 {
-            return nil
-        } else {
-            return array.removeFirst()
-        }
-    }
-    
-    public func peek() -> T? {
-        return array.first
+  private var array = [T]()
+  
+  public var count: Int {
+    return array.count
+  }
+  
+  public var isEmpty: Bool {
+    return array.isEmpty
+  }
+  
+  public mutating func enqueue(element: T) {
+    array.append(element)
+  }
+  
+  public mutating func dequeue() -> T? {
+    if count == 0 {
+      return nil
+    } else {
+      return array.removeFirst()
     }
+  }
+  
+  public func peek() -> T? {
+    return array.first
+  }
 }
 
+// Create a queue and put some elements on it already.
+var queueOfNames = Queue(array: ["Carl", "Lisa", "Stephanie", "Jeff", "Wade"])
 
-var queueOfNames = Queue(array: ["Carl", "Lisa", "Stephanie", "Jeff", "Wade"]) // Initialized queue
-
-queueOfNames.enqueue("Mike") // Adds element to the end of the queue. Queue is now ["Carl", "Lisa", "Stephanie", "Jeff", "Wade", "Mike"]
+// Adds an element to the end of the queue.
+queueOfNames.enqueue("Mike")
 
-queueOfNames.dequeue() // Removes and returns the first element in the queue. Returns "Carl" and then removes it from the queue
+// Queue is now ["Carl", "Lisa", "Stephanie", "Jeff", "Wade", "Mike"]
+print(queueOfNames.array)
 
-queueOfNames.peek() // Returns the first element in the queue. Returns "Lisa" since "Carl" was dequeued on the previous line
+// Remove and return the first element in the queue. This returns "Carl".
+queueOfNames.dequeue()
 
-queueOfNames.isEmpty // Checks to see if the queue is empty. Returns "False" since the queue still has elements in it.
+// Return the first element in the queue.
+// Returns "Lisa" since "Carl" was dequeued on the previous line.
+queueOfNames.peek()
 
+// Check to see if the queue is empty.
+// Returns "false" since the queue still has elements in it.
+queueOfNames.isEmpty

Stack/Stack.playground/Contents.swift

@@ -1,57 +1,60 @@
 /*
+  Stack
 
-Stack
-
-A stack is like an array but with limited functionality. You can only push to add a new element to the top of the stack, pop to remove the element from the top, and peek at the top element without popping it off.
-
-A stack gives you a LIFO or last-in first-out order. The element you pushed last is the first one to come off with the next pop. (A very similar data structure, the queue, is FIFO or first-in first-out.)
-
-Insertion - O(1)
-Deletion - O(1)
+  A stack is like an array but with limited functionality. You can only push 
+  to add a new element to the top of the stack, pop to remove the element from
+  the top, and peek at the top element without popping it off.
 
+  A stack gives you a LIFO or last-in first-out order. The element you pushed 
+  last is the first one to come off with the next pop.
 
+  Push and pop are O(1) operations.
 */
 
-import UIKit
-
 public struct Stack<T> {
-    private var array = [T]()
-    
-    public var count: Int {
-        return array.count
-    }
-    
-    public var isEmpty: Bool {
-        return array.isEmpty
+  private var array = [T]()
+  
+  public var count: Int {
+    return array.count
+  }
+  
+  public var isEmpty: Bool {
+    return array.isEmpty
+  }
+  
+  public mutating func push(element: T) {
+    array.append(element)
+  }
+  
+  public mutating func pop() -> T? {
+    if count == 0 {
+      return nil
+    } else {
+      return array.removeLast()
     }
-    
-    public mutating func push(element: T) {
-        array.append(element)
-    }
-    
-    public mutating func pop() -> T? {
-        if count == 0 {
-            return nil
-        } else {
-            return array.removeLast()
-        }
-    }
-    
-    public func peek() -> T? {
-        return array.last
-    }
-    
+  }
+  
+  public func peek() -> T? {
+    return array.last
+  }
 }
 
+// Create a stack and put some elements on it already.
+var stackOfNames = Stack(array: ["Carl", "Lisa", "Stephanie", "Jeff", "Wade"])
 
-var stackOfNames = Stack(array: ["Carl", "Lisa", "Stephanie", "Jeff", "Wade"]) // Initialized queue
-
-stackOfNames.push("Mike") // Adds element to the end of the stack. Stack is now ["Carl", "Lisa", "Stephanie", "Jeff", "Wade", "Mike"]
-
-stackOfNames.pop() // Removes and returns the last element in the stack. Returns "Mike" and then removes it from the stack
+// Add an element to the top of the stack.
+stackOfNames.push("Mike")
 
-stackOfNames.peek() // Returns the first element in the stack. Returns "Wade" since "Mike" was popped on the previous line
+// The stack is now ["Carl", "Lisa", "Stephanie", "Jeff", "Wade", "Mike"]
+print(stackOfNames.array)
 
-stackOfNames.isEmpty // Checks to see if the stack is empty. Returns "False" since the stack still has elements in it
+// Remove and return the first element from the stack. This returns "Mike".
+stackOfNames.pop()
 
+// Look at the first element from the stack.
+// Returns "Wade" since "Mike" was popped on the previous line.
+stackOfNames.peek()
 
+// Check to see if the stack is empty.
+// Returns "false" since the stack still has elements in it.
+stackOfNames.isEmpty