missing solutions

java/0101-symmetric-tree.java

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isSymmetric(TreeNode root) {
+        return helperMethod(root, root);
+    }
+    public boolean helperMethod(TreeNode left, TreeNode right){
+        if(left==null && right==null) return true;
+        if(left==null || right==null) return false;
+
+        return (left.val==right.val) && helperMethod(left.left, right.right) && helperMethod(left.right, right.left);
+    }
+}

java/0144-binary-tree-preorder-traversal.java

@@ -0,0 +1,16 @@
+class Solution {
+    public List<Integer> preorderTraversal(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode current = root;
+        while(current!=null || !stack.isEmpty()){
+            while(current!=null){
+                res.add(current.val);
+                stack.add(current.right);
+                current = current.left;
+            }
+            current = stack.pop();
+        }
+        return res;
+    }
+}

java/0450-delete-node-in-a-bst.java

@@ -1,32 +1,24 @@
-/** 
- * TC : log (n)
- * 
- * */ 
 class Solution {
-    public TreeNode minimumVal(TreeNode root) {
-        TreeNode curr = root;
-        while (curr != null && curr.left != null) {
-            curr = curr.left;
+    public TreeNode findMin(TreeNode node) {
+        TreeNode current = node;
+        while (current.left != null) {
+            current = current.left;
         }
-        return curr;
+        return current;
     }
 
     public TreeNode deleteNode(TreeNode root, int key) {
         if (root == null) return null;
 
-        if (key > root.val) {
-            root.right = deleteNode(root.right, key);
-        } else if (key < root.val) {
-            root.left = deleteNode(root.left, key);
-        } else {
-            if (root.left == null) {
-                return root.right;
-            } else if (root.right == null) {
-                return root.left;
-            } else {
-                TreeNode minVal = minimumVal(root);
-                root.val = minVal.val;
-                root.right = deleteNode(root.right, minVal.val);
+        if (root.val > key) root.left = deleteNode(root.left, key);
+        else if (root.val < key) root.right = deleteNode(root.right, key);
+        else {
+            if (root.left == null) return root.right;
+            else if (root.right == null) return root.left;
+            else {
+                TreeNode successor = findMin(root.right);
+                root.val = successor.val;
+                root.right = deleteNode(root.right, successor.val);
             }
         }
         return root;

java/0783-minimum-distance-between-bst-nodes.java

@@ -0,0 +1,23 @@
+class Solution {
+    int minDiff = Integer.MAX_VALUE;
+    int prevValue = -1;
+
+    public int minDiffInBST(TreeNode root) {
+        helperMethod(root);
+        return minDiff;
+    }
+
+    public void helperMethod(TreeNode curr) {
+        if (curr == null) return;
+
+        helperMethod(curr.left);
+
+        if (prevValue != -1) {
+            minDiff = Math.min(minDiff, Math.abs(curr.val - prevValue));
+        }
+
+        prevValue = curr.val;
+
+        helperMethod(curr.right);
+    }
+}

java/1898-maximum-number-of-removable-characters.java

@@ -0,0 +1,38 @@
+class Solution {
+    public int maximumRemovals(String s, String p, int[] removable) {
+        return binarySearch(s, p, removable);
+    }
+
+    private boolean isSubsequence(String s, String p, int[] removable, int k) {
+        Set<Integer> removedSet = new HashSet<>();
+        for (int i = 0; i < k; i++) {
+            removedSet.add(removable[i]);
+        }
+
+        int i = 0, j = 0;
+        while (i < s.length() && j < p.length()) {
+            if (removedSet.contains(i) || s.charAt(i) != p.charAt(j)) {
+                i++;
+            } else {
+                i++;
+                j++;
+            }
+        }
+        return j == p.length();
+    }
+
+    private int binarySearch(String s, String p, int[] removable) {
+        int left = 0, right = removable.length + 1;
+
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (isSubsequence(s, p, removable, mid)) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return left - 1;
+    }
+}

python/1898-maximum-number-of-removable-characters.py

@@ -0,0 +1,27 @@
+class Solution:
+    def maximumRemovals(self, s: str, p: str, removable: list[int]) -> int:
+        return self.binary_search(s, p, removable)
+
+    def is_subsequence(self, s: str, p: str, removable: list[int], k: int) -> bool:
+        removed_set = set(removable[:k])
+
+        i, j = 0, 0
+        while i < len(s) and j < len(p):
+            if i in removed_set or s[i] != p[j]:
+                i += 1
+            else:
+                i += 1
+                j += 1
+        return j == len(p)
+
+    def binary_search(self, s: str, p: str, removable: list[int]) -> int:
+        left, right = 0, len(removable) + 1
+
+        while left < right:
+            mid = (left + right) // 2
+            if self.is_subsequence(s, p, removable, mid):
+                left = mid + 1
+            else:
+                right = mid
+
+        return left - 1