davidinga

public class SinglyLinkedList<Element> {
    private var head: SinglyLinkedListNode<Element>?
    private var tail: SinglyLinkedListNode<Element>?
    
    public var isEmpty: Bool {
        return head == nil
    }
    
    public var count: Int {
        var node = head

davidinga

public class DoublyLinkedList<Element> {
    private var head: DoublyLinkedListNode<Element>?
    private var tail: DoublyLinkedListNode<Element>?
    
    public var first: DoublyLinkedListNode<Element>? {
        return head
    }
    
    public var last: DoublyLinkedListNode<Element>? {
        return tail

davidinga

struct Stack<Element> {
    fileprivate var array = [Element]()
    
    public var isEmpty: Bool {
        return array.isEmpty
    }
    
    public var count: Int {
        return array.count
    }

davidinga

struct StackWithLinkedList<Element> {
    let stack = DoublyLinkedList<Element>()
    
    mutating func push(_ element: Element) {
        stack.append(element)
    }
    
    mutating func pop() -> DoublyLinkedListNode<Element>? {
        return stack.remove(node: stack.tail!)
    }

davidinga

public struct Queue<Element> {
    fileprivate let queue = SinglyLinkedList<Element>()
    
    var isEmpty: Bool {
        return queue.isEmpty
    }
    
    var count: Int {
        return queue.count
    }

davidinga

struct HashTable<Key: Hashable, Value> {
    private typealias Element = (key: Key, value: Value)
    private typealias List = SinglyLinkedList<Element>
    
    private var table: [List]
    
    private(set) public var count = 0
    
    var isEmpty: Bool {
        return count == 0

davidinga

struct HashSet<Element: Hashable> {
    private var set: HashTableOnlyKeys<Element>
    
    var isEmpty: Bool {
        return set.isEmpty
    }
    
    var count: Int {
        return set.count
    }

davidinga

public indirect enum BinaryTree {
    case node(
        leftChild: BinaryTree,
        rightChild: BinaryTree,
        value: String
    )
    case empty
}

davidinga

extension BinaryTree {

   public func traverseInOrder() {
        if case let .node(left, right, value) = self {
            left.traverseInOrder()
            print(value + " ", terminator: "")
            right.traverseInOrder()
        }
    }
    

davidinga

func iterativeFib(_ n: Int) -> Int {
    var n1 = 1, n2 = 1, answer = 0, temp = 0
    for _ in 2..<n {
        answer = n1 + n2
        temp = n2
        n2 = answer
        n1 = temp
    }
    return answer
}