From 3c709c07e0c4874968bf50ecd40aef2fcd7a57ae Mon Sep 17 00:00:00 2001
From: Dharma Teja Bandaru <dharmatejabandaru@gmail.com>
Date: Thu, 29 Jan 2026 14:13:59 -0600
Subject: [PATCH] Dharma LL-2 submission

---
 bst-iterator.py                     | 37 ++++++++++++++++++++++
 delete-node-without-head-pointer.py | 14 +++++++++
 intersection-of-ll.py               | 19 +++++++++++
 re-order.py                         | 49 +++++++++++++++++++++++++++++
 4 files changed, 119 insertions(+)
 create mode 100644 bst-iterator.py
 create mode 100644 delete-node-without-head-pointer.py
 create mode 100644 intersection-of-ll.py
 create mode 100644 re-order.py

diff --git a/bst-iterator.py b/bst-iterator.py
new file mode 100644
index 00000000..14e4112d
--- /dev/null
+++ b/bst-iterator.py
@@ -0,0 +1,37 @@
+# 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: Optional[TreeNode]):
+        self.stack =[]
+        self.dfs(root)
+        self.idx =0
+
+    def dfs(self, root):
+        if(root == None):
+            return
+        self.dfs(root.left)
+        self.stack.append(root.val)
+        self.dfs(root.right)
+
+
+    def next(self) -> int:
+        val =self.stack[self.idx]
+        self.idx+=1
+        return val
+
+
+
+    def hasNext(self) -> bool:
+        return True if self.idx < len(self.stack) else False
+
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()
diff --git a/delete-node-without-head-pointer.py b/delete-node-without-head-pointer.py
new file mode 100644
index 00000000..f9bbb085
--- /dev/null
+++ b/delete-node-without-head-pointer.py
@@ -0,0 +1,14 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def deleteNode(self, node):
+        """
+        :type node: ListNode
+        :rtype: void Do not return anything, modify node in-place instead.
+        """
+        node.val = node.next.val
+        node.next = node.next.next
diff --git a/intersection-of-ll.py b/intersection-of-ll.py
new file mode 100644
index 00000000..86a7fcc7
--- /dev/null
+++ b/intersection-of-ll.py
@@ -0,0 +1,19 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
+
+
+        l1 = headA
+        l2 = headB
+
+        while(l1!=l2):
+
+            l1=l1.next if l1 else headB
+            l2=l2.next if l2 else headA
+
+        return l2 or l1
diff --git a/re-order.py b/re-order.py
new file mode 100644
index 00000000..f778d853
--- /dev/null
+++ b/re-order.py
@@ -0,0 +1,49 @@
+# 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: Optional[ListNode]) -> None:
+        """
+        Do not return anything, modify head in-place instead.
+        """
+        slow = head
+        fast = head
+        while(fast and fast.next):
+            slow = slow.next
+            fast = fast.next.next
+        second = slow.next
+        slow.next = None
+
+        reversedHead = self.reverseList(second)
+
+        fast = reversedHead
+        slow = head
+
+        while(fast):
+            temp_slow = slow.next
+            slow.next = fast
+            temp_fast = fast.next
+            fast.next = temp_slow
+            slow = temp_slow
+            fast = temp_fast
+
+
+    def reverseList(self, slow):
+
+
+        prev= None
+
+        while(slow):
+            temp =slow.next
+            slow.next = prev
+            prev = slow
+            slow = temp
+
+        return prev
+
+        while(prev!=None):
+            print(prev.val)
+            prev=prev.next
+