Stack, Queue, Linked List

adagio · adagio · commit d86ab6e537cd · 2017-04-08T02:54:51.000-05:00
diff --git a/Pages/Linked List.xcplaygroundpage/Contents.swift b/Pages/Linked List.xcplaygroundpage/Contents.swift
@@ -0,0 +1,62 @@
+//: [Previous](@previous)
+
+import Foundation
+
+let list = LinkedList<String>()
+list.isEmpty   // true
+list.first     // nil
+list.last
+
+list.append("Hello")
+list.isEmpty         // false
+list.first!.value
+list.last!.value
+
+list.append("World")
+list.first!.value    // "Hello"
+list.last!.value     // "World"
+
+list.first!.previous          // nil
+list.first!.next!.value       // "World"
+list.last!.previous!.value    // "Hello"
+list.last!.next               // nil
+
+list.nodeAt(0)!.value    // "Hello"
+list.nodeAt(1)!.value    // "World"
+list.nodeAt(2)           // nil
+
+list[0]   // "Hello"
+list[1]   // "World"
+// list[2]   // crash!
+
+list.insert("Swift", atIndex: 1)
+list[0]     // "Hello"
+list[1]     // "Swift"
+list[2]     // "World"
+
+list.remove(list.first!)   // "Hello"
+list.count                     // 2
+list[0]                        // "Swift"
+list[1]                        // "World"
+
+//list.removeLast()              // "World"
+//list.count                     // 1
+//list[0]                        // "Swift"
+//
+//list.removeAt(0)          // "Swift"
+//list.count                     // 0
+
+list
+
+let list2 = LinkedList<String>()
+list2.append("Hello")
+list2.append("Swifty")
+list2.append("Universe")
+
+let m = list2.map { s in s.characters.count }
+m
+
+let f = list2.filter { s in s.characters.count > 5 }
+f    // [Universe, Swifty]
+
+//: [Next](@next)
diff --git a/Pages/Linked List.xcplaygroundpage/Sources/LinkedList.swift b/Pages/Linked List.xcplaygroundpage/Sources/LinkedList.swift
@@ -0,0 +1,181 @@
+import Foundation
+
+
+
+public final class LinkedList<T> {
+    
+    public typealias Node = LinkedListNode<T>
+    
+    fileprivate var head: Node?
+    
+    public init() {}
+    
+    public var isEmpty: Bool {
+        return head == nil
+    }
+    
+    public var first: Node? {
+        return head
+    }
+    
+    public var last: Node? {
+        if var node = head {
+            while case let next? = node.next {
+                node = next
+            }
+            return node
+        } else {
+            return nil
+        }
+    }
+    
+    public func append(_ value: T) {
+        let newNode = Node(value: value)
+        if let lastNode = last {
+            newNode.previous = lastNode
+            lastNode.next = newNode
+        } else {
+            head = newNode
+        }
+    }
+    
+    public var count: Int {
+        if var node = head {
+            var c = 1
+            while case let next? = node.next {
+                node = next
+                c += 1
+            }
+            return c
+        } else {
+            return 0
+        }
+    }
+    
+    public func nodeAt(_ index: Int) -> Node? {
+        if index >= 0 {
+            var node = head
+            var i = index
+            while node != nil {
+                if i == 0 { return node }
+                i -= 1
+                node = node!.next
+            }
+        }
+        return nil
+    }
+    
+    public subscript(index: Int) -> T {
+        let node = nodeAt(index)
+        assert(node != nil)
+        return node!.value
+    }
+    
+    private func nodesBeforeAndAfter(_ index: Int) -> (Node?, Node?) {
+        assert(index >= 0)
+        
+        var i = index
+        var next = head
+        var prev: Node?
+        
+        while next != nil && i > 0 {
+            i -= 1
+            prev = next
+            next = next!.next
+        }
+        assert(i == 0)
+        
+        return (prev, next)
+    }
+    
+    public func insert(_ value: T, atIndex index: Int) {
+        let (prev, next) = nodesBeforeAndAfter(index)     // 1
+        
+        let newNode = Node(value: value)    // 2
+        newNode.previous = prev
+        newNode.next = next
+        prev?.next = newNode
+        next?.previous = newNode
+        
+        if prev == nil {                    // 3
+            head = newNode
+        }
+    }
+    
+    public func removeAll() {
+        head = nil
+    }
+    
+    public func remove(_ node: Node) -> T {
+        let prev = node.previous
+        let next = node.next
+        
+        if let prev = prev {
+            prev.next = next
+        } else {
+            head = next
+        }
+        next?.previous = prev
+        
+        node.previous = nil
+        node.next = nil
+        return node.value
+    }
+    
+    public func removeLast() -> T {
+        assert(!isEmpty)
+        return remove(last!)
+    }
+    
+    public func removeAt(_ index: Int) -> T {
+        let node = nodeAt(index)
+        assert(node != nil)
+        return remove(node!)
+    }
+    
+    public func reverse() {
+        var node = head
+        while let currentNode = node {
+            node = currentNode.next
+            swap(&currentNode.next, &currentNode.previous)
+            head = currentNode
+        }
+    }
+    
+    public func map<U>(transform: (T) -> U) -> LinkedList<U> {
+        let result = LinkedList<U>()
+        var node = head
+        while node != nil {
+            result.append(transform(node!.value))
+            node = node!.next
+        }
+        return result
+    }
+    
+    public func filter(predicate: (T) -> Bool) -> LinkedList<T> {
+        let result = LinkedList<T>()
+        var node = head
+        while node != nil {
+            if predicate(node!.value) {
+                result.append(node!.value)
+            }
+            node = node!.next
+        }
+        return result
+    }
+    
+}
+
+extension LinkedList: CustomStringConvertible {
+    public var description: String {
+        var s = "["
+        var node = head
+        while node != nil {
+            s += "\(node!.value)"
+            node = node!.next
+            if node != nil { s += ", " }
+        }
+        return s + "]"
+    }
+}
+
diff --git a/Pages/Linked List.xcplaygroundpage/Sources/LinkedListNode.swift b/Pages/Linked List.xcplaygroundpage/Sources/LinkedListNode.swift
@@ -0,0 +1,15 @@
+import Foundation
+
+
+
+public class LinkedListNode<T> {
+
+    public var value: T
+    public var next: LinkedListNode?
+    public weak var previous: LinkedListNode?
+    
+    public init(value: T) {
+        self.value = value
+    }
+    
+}
diff --git a/Pages/Queue.xcplaygroundpage/Contents.swift b/Pages/Queue.xcplaygroundpage/Contents.swift
@@ -0,0 +1,66 @@
+public struct Queue<T> {
+    fileprivate var array = [T?]()
+    private 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 {
+        if head > 2 {
+            array.removeFirst(head)
+            head = 0
+        }
+        
+        return element
+    }
+    
+    public func peek() -> T? {
+        if isEmpty {
+            return nil
+        } else {
+            return array[head]
+        }
+    }
+}
+
+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
+
+q.dequeue()         // "Tim"
+q.array             // [{Some "Grace"}]
+q.count             // 1
+
diff --git a/Pages/Stack.xcplaygroundpage/Contents.swift b/Pages/Stack.xcplaygroundpage/Contents.swift
@@ -0,0 +1,35 @@
+public struct Stack<T> {
+    private var array = [T]()
+    
+    public var isEmpty: Bool {
+        return array.isEmpty
+    }
+    
+    public var count: Int {
+        return array.count
+    }
+    
+    public mutating func push(_ element: T) {
+        array.append(element)
+    }
+    
+    public mutating func pop() -> T? {
+        return array.popLast()
+    }
+    
+    public func peek() -> T? {
+        return array.last
+    }
+}
+
+var stack = Stack<Int>()
+
+stack.push(10)
+
+stack.push(3)
+
+stack.push(57)
+
+stack.pop()
+
+stack.pop()
diff --git a/README.md b/README.md
@@ -0,0 +1,3 @@
+# Swift Algorithm Club!
+
+[Swift Algorithm Club by RayWenderlich](https://github.com/raywenderlich/swift-algorithm-club)
diff --git a/contents.xcplayground b/contents.xcplayground
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='6.0' target-platform='ios' executeOnSourceChanges='false'>
+    <pages>
+        <page name='Queue'/>
+        <page name='Stack'/>
+        <page name='Linked List'/>
+    </pages>
+</playground>
diff --git a/playground.xcworkspace/contents.xcworkspacedata b/playground.xcworkspace/contents.xcworkspacedata
diff --git a/playground.xcworkspace/xcuserdata/francocedillo.xcuserdatad/UserInterfaceState.xcuserstate b/playground.xcworkspace/xcuserdata/francocedillo.xcuserdatad/UserInterfaceState.xcuserstate
diff --git a/xcuserdata/francocedillo.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist b/xcuserdata/francocedillo.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Bucket
+   type = "1"
+   version = "2.0">
+</Bucket>

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+# Swift Algorithm Club!`
	`2`	`+`
	`3`	`+[Swift Algorithm Club by RayWenderlich](https://github.com/raywenderlich/swift-algorithm-club)`