142_Linked_List_Cycle_II

143_Reorder_List
144_Binary_Tree_Preorder_Traversal
145_Binary_Tree_Postorder_Traversal
146_LRU_Cache

Author: qiyuangong

README.md

@@ -41,6 +41,11 @@
 | 137 | [Single Number II](https://leetcode.com/problems/single-number-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/137_Single_Number_II.py) | 1. ctypes 32 % 3 and &, O(n) and O(1)<br>2. ones, twos, threes as bitmask (e.g. ones represents ith bit had appeared once), O(n) and O(1) | 
 | 138 | [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/138_Copy_List_with_Random_Pointer.py) | 1. Hash O(n) and O(n)<br>2.  Modify original structure: Original->Copy->Original, then node.next.random = node.random.next, O(n) and O(1) |
 | 141 | [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/.py) | 1. Hash or set<br> 2. Two points (fast and slow)<br>3. Add a max and check if reach the max |
+| 142 | [Linked List Cycle II](https://discuss.leetcode.com/topic/2975/o-n-solution-by-using-two-pointers-without-change-anything) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/142_Linked_List_Cycle_II.py) | Two points, a+b=nr |
+| 143 | [Reorder List](https://leetcode.com/problems/reorder-list/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/143_Reorder_List.py) | 1. List as index to rebuild relation, O(n) and O(n)<br>2. Two points, O(n) and O(1) |
+| 144 | [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/144_Binary_Tree_Preorder_Traversal.py) | 1. Recursion, O(n) and O(n)<br>2. Stack, O(n) and O(n) |
+| 145 | [Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/145_Binary_Tree_Postorder_Traversal.py) | 1. Recursion, O(n) and O(n)<br>2. Stack, O(n) and O(n)  |
+| 146 | [LRU Cache](https://leetcode.com/problems/lru-cache/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/146_LRU_Cache.py) | 1. Queue and dict<br>2. OrderedDict |
 | 150 | [Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/150_Evaluate_Reverse_Polish_Notation.py) | Stack |
 | 151 | [Reverse Words in a String](https://discuss.leetcode.com/category/159/reverse-words-in-a-string) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/151_Reverse_Words_in_a_String.py)| 1. Python split by space <br>2. Reverse all and reverse words |
 | 155 | [Min Stack](https://leetcode.com/problems/min-stack/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/155_Min_Stack.py) | Add another stack for min stack, maintance this stack when the main stack pop or push |

python/142_Linked_List_Cycle_II.py

@@ -0,0 +1,29 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def detectCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        # Two points
+        # https://discuss.leetcode.com/topic/2975/o-n-solution-by-using-two-pointers-without-change-anything
+        try:
+            fast = head.next.next
+            slow = head.next
+
+            while fast != slow:
+                fast = fast.next.next
+                slow = slow.next
+        except:
+            return None
+        slow = head
+        while fast != slow:
+            fast = fast.next
+            slow = slow.next
+        return fast
+

python/143_Reorder_List.py

@@ -0,0 +1,53 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    # def reorderList(self, head):
+    #     """
+    #     :type head: ListNode
+    #     :rtype: void Do not return anything, modify head in-place instead.
+    #     """
+    #     # List as index to rebuild relation
+    #     if not head:
+    #         return
+    #     dmap = []
+    #     current = head
+    #     while current is not None:
+    #         dmap.append(current)
+    #         current = current.next
+    #     ls = len(dmap)
+    #     for i in range(ls / 2):
+    #         t = -1 * (i + 1)
+    #         dmap[t].next = dmap[i].next
+    #         dmap[i].next = dmap[t]
+    #     dmap[ls / 2].next = None
+
+    def reorderList(self, head):
+        # Two points
+        if head is None or head.next is None:
+            return
+        p1, p2 = head, head.next
+        while p2 and p2.next:
+            p1 = p1.next
+            p2 = p2.next.next
+        head2 = p1.next
+        p1.next = None
+        p2 = head2.next
+        head2.next = None
+        # reverse mid->end to end->mid
+        while p2:
+            temp = p2.next
+            p2.next = head2
+            head2 = p2
+            p2 = temp
+        p1, p2 = head, head2
+        # merge
+        while p1:
+            temp = p1.next
+            p1.next = p2
+            p1 = p1.next
+            p2 = temp
+

python/144_Binary_Tree_Preorder_Traversal.py

@@ -0,0 +1,43 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    # def __init__(self):
+    #     self.result = []
+    #
+    # def preorderTraversal(self, root):
+    #     """
+    #     :type root: TreeNode
+    #     :rtype: List[int]
+    #     """
+    #     if root is None:
+    #         return []
+    #     self.preorderTraversalHelper(root)
+    #     return self.result
+    #
+    # def preorderTraversalHelper(self, node):
+    #     if node is None:
+    #         return
+    #     self.result.append(node.val)
+    #     self.preorderTraversalHelper(node.left)
+    #     self.preorderTraversalHelper(node.right)
+
+    def preorderTraversal(self, root):
+        # stack
+        if root is None:
+            return []
+        res = []
+        stack = [root]
+        while len(stack) > 0:
+            curr = stack.pop()
+            res.append(curr.val)
+            if curr.right is not None:
+                stack.append(curr.right)
+            if curr.left is not None:
+                stack.append(curr.left)
+        return res
+

python/145_Binary_Tree_Postorder_Traversal.py

@@ -0,0 +1,41 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    # def postorderTraversal(self, root):
+    #     """
+    #     :type root: TreeNode
+    #     :rtype: List[int]
+    #     """
+    #     # Recursion
+    #     if root is None:
+    #         return []
+    #     res = []
+    #     self.postorderHelp(root, res)
+    #     return res
+    #
+    # def postorderHelp(self, node, stack):
+    #     if node is None:
+    #         return
+    #     self.postorderHelp(node.left, stack)
+    #     self.postorderHelp(node.right, stack)
+    #     stack.append(node.val)
+
+    def postorderTraversal(self, root):
+        # Stack
+        if root is None:
+            return []
+        res = []
+        stack = [root]
+        while len(stack) > 0:
+            curr = stack.pop()
+            res.insert(0, curr.val)
+            if curr.left is not None:
+                stack.append(curr.left)
+            if curr.right is not None:
+                stack.append(curr.right)
+        return res

python/146_LRU_Cache.py

@@ -0,0 +1,59 @@
+class LRUCache:
+    def __init__(self, capacity):
+        """
+        :type capacity: int
+        """
+        self.capacity = capacity
+        self.cache = {}
+        self.queue = []
+
+    def updateQueue(self, key):
+        self.queue.remove(key)
+        self.queue.insert(0, key)
+
+    def get(self, key):
+        """
+        :rtype: int
+        """
+        if key in self.cache:
+            self.updateQueue(key)
+            return self.cache[key]
+        else:
+            return -1
+
+    def set(self, key, value):
+        """
+        :type key: int
+        :type value: int
+        :rtype: nothing
+        """
+        if not key or not value:
+            return None
+        if key in self.cache:
+            self.queue.remove(key)
+        elif len(self.queue) == self.capacity:
+            del self.cache[self.queue.pop(-1)]
+
+        self.cache[key] = value
+        self.queue.insert(0, key)
+
+    # def __init__(self, capacity):
+    #     self.dic = collections.OrderedDict()
+    #     self.remain = capacity
+    #
+    # def get(self, key):
+    #     if key not in self.dic:
+    #         return -1
+    #     v = self.dic.pop(key)
+    #     self.dic[key] = v  # set key as the newest one
+    #     return v
+    #
+    # def set(self, key, value):
+    #     if key in self.dic:
+    #         self.dic.pop(key)
+    #     else:
+    #         if self.remain > 0:
+    #             self.remain -= 1
+    #         else:  # self.dic is full
+    #             self.dic.popitem(last=False)
+    #     self.dic[key] = value