LeetCode 206. Reverse Linked List

Author: raul-sauco

README.md

@@ -30,6 +30,7 @@ Proposed solutions to some LeetCode problems. The first column links to the prob
 | [160. Intersection of Two Linked Lists][lc160]                          | Easy       | [python](leetcode/intersection-of-two-linked-lists.py)                        |
 | [167. Two Sum II - Input Array Is Sorted][lc167]                        | Easy       | [python](leetcode/two-sum-ii-input-array-is-sorted.py)                        |
 | [205. Isomorphic Strings][lc205]                                        | Easy       | [python](leetcode/isomorphic-strings.py)                                      |
+| [206. Reverse Linked List][lc206]                                       | Easy       | [python](leetcode/reverse-linked-list.py)                                     |
 | [208. Implement Trie (Prefix Tree)][lc208]                              | Medium     | [python](leetcode/implement-trie-prefix-tree.py)                              |
 | [211. Design Add and Search Words Data Structure][lc211]                | Medium     | [python](leetcode/design-add-and-search-words-data-structure.py)              |
 | [215. Kth Largest Element in an Array][lc215]                           | Medium     | [python](leetcode/kth-largest-element-in-an-array.py)                         |
@@ -90,6 +91,7 @@ Proposed solutions to some LeetCode problems. The first column links to the prob
 [lc160]: https://leetcode.com/problems/intersection-of-two-linked-lists/
 [lc167]: https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/
 [lc205]: https://leetcode.com/problems/isomorphic-strings/
+[lc206]: https://leetcode.com/problems/reverse-linked-list/
 [lc208]: https://leetcode.com/problems/implement-trie-prefix-tree/
 [lc211]: https://leetcode.com/problems/design-add-and-search-words-data-structure/
 [lc215]: https://leetcode.com/problems/kth-largest-element-in-an-array/

leetcode/data.py

@@ -20,6 +20,13 @@ def __init__(self):
         self.children = defaultdict(TrieNode)
         self.isWord = False
 
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
 # Useful for testing binary tree problems using the strings provided on the description
 # https://leetcode.com/problems/recover-binary-search-tree/discuss/32539/Tree-Deserializer-and-Visualizer-for-Python
 

leetcode/merge_two_sorted_lists.py

@@ -3,7 +3,7 @@
 
 from typing import List, Optional
 
-from leetcode.helpers import BColors
+from helpers import BColors
 
 
 # Definition for singly-linked list.
@@ -13,6 +13,8 @@ def __init__(self, val=0, next=None):
         self.next = next
 
 
+# Runtime: 40 ms, faster than 89.68% of Python3 online submissions for Merge Two Sorted Lists.
+# Memory Usage: 14 MB, less than 32.07 % of Python3 online submissions for Merge Two Sorted Lists.
 class Solution:
     def mergeTwoLists(self, node1: Optional[ListNode], node2: Optional[ListNode]) -> Optional[ListNode]:
         head_pointer = temp = ListNode()

leetcode/reverse-linked-list.py

@@ -0,0 +1,46 @@
+# https://leetcode.com/problems/reverse-linked-list/
+
+
+from typing import List, Optional
+from data import ListNode
+
+
+# Runtime: 42 ms, faster than 81.83% of Python3 online submissions for Reverse Linked List.
+# Memory Usage: 15.4 MB, less than 55.68 % of Python3 online submissions for Reverse Linked List.
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head:
+            return
+        current = head
+        next = current.next
+        while next:
+            prev = current
+            current = next
+            next = current.next
+            current.next = prev
+        head.next = None
+        return current
+
+
+def linkedListToArray(result: List[int], node: ListNode) -> List[int]:
+    result.append(node.val)
+    if node.next:
+        return linkedListToArray(result, node.next)
+    else:
+        return result
+
+
+def test():
+    node5 = ListNode(5)
+    node4 = ListNode(4, node5)
+    node3 = ListNode(3, node4)
+    node2 = ListNode(2, node3)
+    node1 = ListNode(1, node2)
+    sol = Solution()
+    result = linkedListToArray([], sol.reverseList(node1))
+    expected = [5, 4, 3, 2, 1]
+    assert result == expected, f'{result} != {expected}'
+    assert sol.reverseList(None) == None
+
+
+test()