Updates

Author: wuduhren

problems/python3/copy-list-with-random-pointer.py

@@ -0,0 +1,34 @@
+"""
+Time: O(N)
+Space: O(1)
+
+The easiest way would be maintaining a hash map for original node to the copy and the other way around. Then the rest is easy.
+But this will take us O(N) of extra space.
+
+Two pass solution with constant space.
+First pass.
+Create a copy of the original and store it inside "random".
+The copy points to original's next and original's random.
+
+Second pass.
+Iterate through the nodes again.
+This time we adjust the copy to point to the other copies.
+"""
+class Solution:
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        if not head: return head
+        
+        node = head
+        while node:
+            copy = Node(node.val, node.next, node.random)
+            node.random = copy
+            node = node.next
+        
+        node = head
+        while node:
+            newNode = node.random
+            if node.next: newNode.next = node.next.random
+            if newNode.random: newNode.random = newNode.random.random
+            node = node.next
+        
+        return head.random

problems/python3/largest-rectangle-in-histogram.py

@@ -0,0 +1,21 @@
+"""
+[0] For each height, if the it is lower than the previous one, it means that the previous are not able to extend anymore. So we calculate its area.
+
+[1] If the previous area, is larger than the current one, it means that the current one are able to extand backward.
+"""
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
+        maxArea = 0
+        stack = []
+        
+        heights.append(0) #dummy for the ending
+        
+        for i, h in enumerate(heights):
+            start = i
+            while stack and h<stack[-1][1]: #[0]
+                j, h2 = stack.pop()
+                maxArea = max(maxArea, h2*(i-j))
+                start = j
+            stack.append((start, h)) #[1]
+        
+        return maxArea

problems/python3/merge-two-sorted-lists.py

@@ -0,0 +1,15 @@
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        head = ListNode() #dummy
+        node = head
+        while list1 and list2:
+            if list1.val<list2.val:
+                node.next = list1
+                list1 = list1.next
+            else:
+                node.next = list2
+                list2 = list2.next
+            node = node.next
+        
+        node.next = list1 or list2
+        return head.next

problems/python3/remove-nth-node-from-end-of-list.py

@@ -0,0 +1,47 @@
+#Two pass.
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        #count the length of the linked list
+        node = head
+        count = 0
+        while node:
+            count += 1
+            node = node.next
+        
+
+        node = head
+        steps = count-n-1
+        
+        #steps==-1 means that we need to remove the first node
+        if steps==-1: return head.next
+        
+        #traverse to the node before the node we wanted to remove
+        while steps>0:
+            node = node.next
+            steps -= 1
+        
+        #remove "node.next"
+        node.next = node.next.next
+        
+        return head
+
+
+#One pass. Fast pointer is ahead of slow pointer by n+1
+#So slow pointer will stop at the node before the node we wanted to remove
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        dummy = ListNode()
+        dummy.next = head
+
+        ahead = n+1
+        fast = dummy
+        slow = dummy
+        
+        while fast:
+            fast = fast.next
+            ahead -= 1
+            if ahead<0: slow = slow.next
+        
+        slow.next = slow.next.next
+
+        return dummy.next

problems/python3/reorder-list.py

@@ -0,0 +1,37 @@
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        #find the middle point
+        slow = head
+        fast = head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+        middle = slow.next
+
+        #reverse the linked list after the middle point
+        middle = self.reverseList(middle)
+
+        #separate the linked list before the middle
+        slow.next = None
+        
+        #merge two linked list
+        node = head
+        while middle and node:
+            nextNode = node.next
+            node.next = middle
+            middle = middle.next
+            node.next.next = nextNode
+            node = nextNode
+        return head
+    
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        pre = None
+        node = head
+        
+        while node:
+            nextNode = node.next
+            node.next = pre
+            if not nextNode: return node
+            pre = node
+            node = nextNode
+        

problems/python3/reverse-linked-list.py

@@ -0,0 +1,21 @@
+#Recursive
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head or not head.next: return head
+        temp = self.reverseList(head.next)
+        head.next.next = head
+        head.next = None
+        return temp
+
+#Iterative
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        pre = None
+        node = head
+        
+        while node:
+            nextNode = node.next
+            node.next = pre
+            if not nextNode: return node
+            pre = node
+            node = nextNode