Updated LinkedList.swift for Swift 3

Author: tuliot

Linked List/LinkedList.playground/Sources/LinkedList.swift

@@ -0,0 +1,191 @@
+/*
+  Doubly-linked list
+
+  Most operations on the linked list have complexity O(n).
+*/
+public class LinkedListNode<T> {
+  var value: T
+  var next: LinkedListNode?
+  weak var previous: LinkedListNode?
+
+  public init(value: T) {
+    self.value = value
+  }
+}
+
+public class LinkedList<T> {
+  public typealias Node = LinkedListNode<T>
+
+  private var head: Node?
+
+  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 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 nodeAtIndex(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 = nodeAtIndex(index)
+    assert(node != nil)
+    return node!.value
+  }
+
+  public func append(value: T) {
+    let newNode = Node(value: value)
+    if let lastNode = last {
+      newNode.previous = lastNode
+      lastNode.next = newNode
+    } else {
+      head = newNode
+    }
+  }
+
+  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)  // if > 0, then specified index was too large
+
+    return (prev, next)
+  }
+
+  public func insert(value: T, atIndex index: Int) {
+    let (prev, next) = nodesBeforeAndAfter(index)
+
+    let newNode = Node(value: value)
+    newNode.previous = prev
+    newNode.next = next
+    prev?.next = newNode
+    next?.previous = newNode
+
+    if prev == nil {
+      head = newNode
+    }
+  }
+
+  public func removeAll() {
+    head = nil
+  }
+
+  public func removeNode(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 removeNode(last!)
+  }
+
+  public func removeAtIndex(index: Int) -> T {
+    let node = nodeAtIndex(index)
+    assert(node != nil)
+    return removeNode(node!)
+  }
+}
+
+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 + "]"
+  }
+}
+
+extension LinkedList {
+  public func reverse() {
+    var node = head
+    while let currentNode = node {
+      node = currentNode.next
+      swap(&currentNode.next, &currentNode.previous)
+      head = currentNode
+    }
+  }
+}
+
+extension LinkedList {
+  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
+  }
+}

Linked List/LinkedList.swift

@@ -16,7 +16,7 @@ public class LinkedListNode<T> {
 public class LinkedList<T> {
   public typealias Node = LinkedListNode<T>
 
-  private var head: Node?
+  fileprivate var head: Node?
 
   public var isEmpty: Bool {
     return head == nil
@@ -64,7 +64,7 @@ public class LinkedList<T> {
   }
 
   public subscript(index: Int) -> T {
-    let node = nodeAtIndex(index)
+    let node = nodeAtIndex(index: index)
     assert(node != nil)
     return node!.value
   }
@@ -97,7 +97,7 @@ public class LinkedList<T> {
   }
 
   public func insert(value: T, atIndex index: Int) {
-    let (prev, next) = nodesBeforeAndAfter(index)
+    let (prev, next) = nodesBeforeAndAfter(index: index)
 
     let newNode = Node(value: value)
     newNode.previous = prev
@@ -132,13 +132,13 @@ public class LinkedList<T> {
 
   public func removeLast() -> T {
     assert(!isEmpty)
-    return removeNode(last!)
+    return removeNode(node: last!)
   }
 
   public func removeAtIndex(index: Int) -> T {
-    let node = nodeAtIndex(index)
+    let node = nodeAtIndex(index: index)
     assert(node != nil)
-    return removeNode(node!)
+    return removeNode(node: node!)
   }
 }
 
@@ -167,22 +167,22 @@ extension LinkedList {
 }
 
 extension LinkedList {
-  public func map<U>(transform: T -> U) -> LinkedList<U> {
+  public func map<U>(transform: (T)-> U) -> LinkedList<U> {
     let result = LinkedList<U>()
     var node = head
     while node != nil {
-      result.append(transform(node!.value))
+        result.append(value: transform(node!.value))
       node = node!.next
     }
     return result
   }
 
-  public func filter(predicate: T -> Bool) -> LinkedList<T> {
+  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)
+        result.append(value: node!.value)
       }
       node = node!.next
     }