Completed Linked List 2

Problem_1.py

@@ -0,0 +1,33 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class BSTIterator:
+
+    def __init__(self, root):
+        self.st = []
+        self.st.append(root)
+        self._dfs(root.left)
+
+    def _dfs(self, root):
+        if not root:
+            return
+        self.st.append(root)
+        self._dfs(root.left)
+
+    def next(self):
+        top = self.st.pop()
+        if top.right:
+            self._dfs(top.right)
+        return top.val
+
+    def hasNext(self):
+        return len(self.st) > 0
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()

Problem_2.py

@@ -0,0 +1,32 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reorderList(self, head):
+        if not head or not head.next:
+            return head
+        slow, fast = head, head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+        revHead = self.reverseLL(slow.next)
+        slow.next = None
+        slow = head
+        while revHead:
+            nextslow = slow.next
+            nextrevHead = revHead.next
+            slow.next = revHead
+            revHead.next = nextslow
+            slow = nextslow
+            revHead = nextrevHead
+        return head
+
+    def reverseLL(self, head):
+        if not head or not head.next:
+            return head
+        newHead = self.reverseLL(head.next)
+        head.next.next = head
+        head.next = None
+        return newHead

Problem_3.py

@@ -0,0 +1,5 @@
+class Solution:
+    def deleteNode(self, del_node):
+        nextNode = del_node.next
+        del_node.data = nextNode.data
+        del_node.next = nextNode.next

Problem_4.py

@@ -0,0 +1,24 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution:
+    def getIntersectionNode(
+        self, headA, headB
+    ):
+        currA, currB = headA, headB
+        while currA != currB:
+            if currA == currB:
+                return currA
+            if currA:
+                currA = currA.next
+            else:
+                currA = headB
+            if currB:
+                currB = currB.next
+            else:
+                currB = headA
+        return currA