Merge pull request kodecocodes#662 from ysn551/fix-LinkedList

Fixed LinkedList:

Author: kelvinlauKL

Linked List/LinkedList.playground/Contents.swift

@@ -42,54 +42,60 @@ public final class LinkedList<T> {
 
   /// Computed property to iterate through the linked list and return the last node in the list (if any)
   public var last: Node? {
-    if var node = head {
-      while case let next? = node.next {
-        node = next
-      }
-      return node
-    } else {
+    guard var node = head else {
       return nil
     }
+    
+    while let next = node.next {
+      node = next
+    }
+    return node
   }
 
   /// Computed property to iterate through the linked list and return the total number of nodes
   public var count: Int {
-    if var node = head {
-      var c = 1
-      while case let next? = node.next {
-        node = next
-        c += 1
-      }
-      return c
-    } else {
+    guard var node = head else {
       return 0
     }
+    
+    var count = 1
+    while let next = node.next {
+      node = next
+      count += 1
+    }
+    return count
   }
 
   /// Function to return the node at a specific index. Crashes if index is out of bounds (0...self.count)
   ///
   /// - Parameter index: Integer value of the node's index to be returned
   /// - Returns: Optional LinkedListNode
-  public func node(atIndex 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
-      }
+  public func node(at index: Int) -> Node {
+    assert(head != nil, "List is empty")
+    assert(index >= 0, "index must be greater than 0")
+    
+    if index == 0 {
+        return head!
+    } else {
+        var node = head!.next
+        for _ in 1..<index {
+            node = node?.next
+            if node == nil {
+                break
+            }
+        }
+        
+        assert(node != nil, "index is out of bounds.")
+        return node!
     }
-    return nil
   }
 
   /// Subscript function to return the node at a specific index
   ///
   /// - Parameter index: Integer value of the requested value's index
   public subscript(index: Int) -> T {
-    let node = self.node(atIndex: index)
-    assert(node != nil)
-    return node!.value
+    let node = self.node(at: index)
+    return node.value
   }
 
   /// Append a value to the end of the list
@@ -104,7 +110,7 @@ public final class LinkedList<T> {
   ///
   /// - Parameter node: The node containing the value to be appended
   public func append(_ node: Node) {
-    let newNode = LinkedListNode(value: node.value)
+    let newNode = node
     if let lastNode = last {
       newNode.previous = lastNode
       lastNode.next = newNode
@@ -124,78 +130,57 @@ public final class LinkedList<T> {
     }
   }
 
-  /// A private helper funciton to find the nodes before and after a specified index. Crashes if index is out of bounds (0...self.count)
-  ///
-  /// - Parameter index: Integer value of the index between the nodes.
-  /// - Returns: A tuple of 2 nodes before & after the specified index respectively.
-  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)
-  }
-
   /// Insert a value at a specific index. Crashes if index is out of bounds (0...self.count)
   ///
   /// - Parameters:
   ///   - value: The data value to be inserted
   ///   - index: Integer value of the index to be insterted at
-  public func insert(_ value: T, atIndex index: Int) {
+  public func insert(_ value: T, at index: Int) {
     let newNode = Node(value: value)
-    self.insert(newNode, atIndex: index)
+    self.insert(newNode, at: index)
   }
 
   /// Insert a copy of a node at a specific index. Crashes if index is out of bounds (0...self.count)
   ///
   /// - Parameters:
   ///   - node: The node containing the value to be inserted
   ///   - index: Integer value of the index to be inserted at
-  public func insert(_ node: Node, atIndex index: Int) {
-    let (prev, next) = nodesBeforeAndAfter(index: index)
-    let newNode = LinkedListNode(value: node.value)
-    newNode.previous = prev
-    newNode.next = next
-    prev?.next = newNode
-    next?.previous = newNode
-
-    if prev == nil {
+  public func insert(_ newNode: Node, at index: Int) {
+    if index == 0 {
+      newNode.next = head
+      head?.previous = newNode
       head = newNode
+    } else {
+      let prev = node(at: index-1)
+      let next = prev.next
+      newNode.previous = prev
+      newNode.next = next
+      next?.previous = newNode
+      prev.next = newNode
     }
   }
-
+    
   /// Insert a copy of a LinkedList at a specific index. Crashes if index is out of bounds (0...self.count)
   ///
   /// - Parameters:
   ///   - list: The LinkedList to be copied and inserted
   ///   - index: Integer value of the index to be inserted at
-  public func insert(_ list: LinkedList, atIndex index: Int) {
+  public func insert(_ list: LinkedList, at index: Int) {
     if list.isEmpty { return }
-    var (prev, next) = nodesBeforeAndAfter(index: index)
-    var nodeToCopy = list.head
-    var newNode: Node?
-    while let node = nodeToCopy {
-      newNode = Node(value: node.value)
-      newNode?.previous = prev
-      if let previous = prev {
-        previous.next = newNode
-      } else {
-        self.head = newNode
-      }
-      nodeToCopy = nodeToCopy?.next
-      prev = newNode
+    
+    if index == 0 {
+      list.last?.next = head
+      head = list.head
+    } else {
+      let prev = node(at: index-1)
+      let next = prev.next
+
+      prev.next = list.head
+      list.head?.previous = prev
+
+      list.last?.next = next
+      next?.previous = list.last?.next
     }
-    prev?.next = next
-    next?.previous = prev
   }
 
   /// Function to remove all nodes/value from the list
@@ -235,10 +220,9 @@ public final class LinkedList<T> {
   ///
   /// - Parameter index: Integer value of the index of the node to be removed
   /// - Returns: The data value contained in the deleted node
-  @discardableResult public func remove(atIndex index: Int) -> T {
-    let node = self.node(atIndex: index)
-    assert(node != nil)
-    return remove(node: node!)
+  @discardableResult public func remove(at index: Int) -> T {
+    let node = self.node(at: index)
+    return remove(node: node)
   }
 }
 
@@ -324,7 +308,7 @@ list.first                    // nil
 list.last                     // nil
 
 list.append("Hello")
-list.isEmpty
+list.isEmpty                  // false
 list.first!.value             // "Hello"
 list.last!.value              // "Hello"
 list.count                    // 1
@@ -339,9 +323,9 @@ list.first!.next!.value       // "World"
 list.last!.previous!.value    // "Hello"
 list.last!.next               // nil
 
-list.node(atIndex: 0)!.value    // "Hello"
-list.node(atIndex: 1)!.value    // "World"
-list.node(atIndex: 2)           // nil
+list.node(at: 0).value    // "Hello"
+list.node(at: 1).value    // "World"
+//list.node(at: 2)           // crash!
 
 list[0]     // "Hello"
 list[1]     // "World"
@@ -354,35 +338,59 @@ list.append(list2)            // [Hello, World, Goodbye, World]
 list2.removeAll()             // [ ]
 list2.isEmpty                 // true
 list.removeLast()             // "World"
-list.remove(atIndex: 2)       // "Goodbye"
+list.remove(at: 2)       // "Goodbye"
 
-list.insert("Swift", atIndex: 1)
+list.insert("Swift", at: 1)
 list[0]     // "Hello"
 list[1]     // "Swift"
 list[2]     // "World"
 print(list)
 
 list.reverse()   // [World, Swift, Hello]
 
-list.node(atIndex: 0)!.value = "Universe"
-list.node(atIndex: 1)!.value = "Swifty"
-let m = list.map { s in s.characters.count }
+list.node(at: 0).value = "Universe"
+list.node(at: 1).value = "Swifty"
+let m = list.map { s in s.count }
 m    // [8, 6, 5]
-let f = list.filter { s in s.characters.count > 5 }
+let f = list.filter { s in s.count > 5 }
 f    // [Universe, Swifty]
 
 list.remove(node: list.first!) // "Universe"
 list.count                     // 2
 list[0]                        // "Swifty"
 list[1]                        // "Hello"
 
+list.count                     // 2
 list.removeLast()              // "Hello"
+list.head?.value
 list.count                     // 1
 list[0]                        // "Swifty"
 
-list.remove(atIndex: 0)        // "Swifty"
+list.remove(at: 0)        // "Swifty"
 list.count                     // 0
 
+let list3 = LinkedList<String>()
+list3.insert("2", at: 0) // [2]
+list3.count                   // 1
+list3.insert("4", at: 1) // [2,4]
+list3.count                   // 2
+list3.insert("5", at: 2) // [2,4,5]
+list3.count                   // 3
+list3.insert("3", at: 1) // [2,3,4,5]
+list3.insert("1", at: 0) // [1,2,3,4,5]
+
+let list4 = LinkedList<String>()
+list4.insert(list3, at: 0) // [1,2,3,4,5]
+list4.count                     // 5
+
+let list5 = LinkedList<String>()
+list5.append("0")                // [0]
+list5.insert("End", at:1)   // [0,End]
+list5.count                      // 2
+list5.insert(list4, at: 1)  // [0,1,2,3,4,5,End]
+list5.count                      // 7
+
+
 let linkedList: LinkedList<Int> = [1, 2, 3, 4] // [1, 2, 3, 4]
 linkedList.count               // 4
 linkedList[0]                  // 1