Merge branch 'neetcode-gh:main' into main

Author: edo-ce

cpp/neetcode_150/07_trees/validate_binary_search_tree.cpp

@@ -1,8 +1,8 @@
 /*
     Given root of binary tree, determine if it's valid (left all < curr, right all > curr)
-
+    
     Inorder traversal & check if prev >= curr, recursive/iterative solutions
-
+    
     Time: O(n)
     Space: O(n)
 */

csharp/100-Same-Tree.cs

@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public bool IsSameTree(TreeNode p, TreeNode q) {
+        if (p == null || q == null)
+            return p == q;
+        
+        return
+            p.val == q.val &&
+            IsSameTree(p.left, q.left) &&
+            IsSameTree(p.right, q.right);
+    }
+}

csharp/572-Subtree-of-Another-Tree.cs

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode  {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public bool IsSameTree(TreeNode one, TreeNode another)     {
+        if (one == null || another == null)
+            return one == another;
+        
+        return
+            one.val == another.val &&
+            IsSameTree(one.left, another.left) &&
+            IsSameTree(one.right, another.right);
+    }
+    public bool IsSubtree(TreeNode root, TreeNode subRoot) {
+        if (subRoot == null) return true;
+        if (root == null) return false;
+
+        var nodeToVisit = new Queue<TreeNode>();
+
+        nodeToVisit.Enqueue(root);
+
+        while (nodeToVisit.Count > 0) {
+            var cur = nodeToVisit.Dequeue();
+            var isSame = IsSameTree(cur, subRoot);
+            if (isSame) return true;
+
+            if (cur.left != null)
+                nodeToVisit.Enqueue(cur.left);
+            if (cur.right != null)
+                nodeToVisit.Enqueue(cur.right);
+        }
+
+        return false;
+    }
+}

java/4-Median-of-Two-Sorted-Arrays.java

@@ -1,5 +1,8 @@
-/*Brute-force solution (Linear time)*/
-
+/*Brute-force solution (Linear)*/
+/*
+// Runtime: O(m+n)
+// Extra Space: O(m+n)
+// 
 class Solution {
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
         int m = nums1.length;
@@ -18,3 +21,58 @@ public double findMedianSortedArrays(int[] nums1, int[] nums2) {
         } else return (float)nums[(m+n-1)/2];
     }
 }
+*/
+/* Optimized solution (Logarithmic) */
+
+// Runtime: O(log(min(m,n)))
+// Extra Space: O(1)
+
+class Solution {
+    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        int m = nums1.length;
+        int n = nums2.length;
+        
+        if(m > n){
+            return findMedianSortedArrays(nums2, nums1);
+        }
+        
+        int total = m + n;
+        int half = (total + 1) / 2;
+        
+        int left = 0;
+        int right = m;
+        
+        var result = 0.0;
+        
+        while(left <= right){
+            int i = left + (right - left) / 2;
+            int j = half - i;
+            
+            // get the four points around possible median
+            int left1 = (i > 0) ? nums1[i - 1] : Integer.MIN_VALUE;
+            int right1 = (i < m) ? nums1[i] : Integer.MAX_VALUE;
+            int left2 = (j > 0) ? nums2[j - 1] : Integer.MIN_VALUE;
+            int right2 = (j < n) ? nums2[j] : Integer.MAX_VALUE;
+            
+            // partition is correct
+            if (left1 <= right2 && left2 <= right1) {
+                // even
+                if (total % 2 == 0) {
+                    result = (Math.max(left1, left2) + Math.min(right1, right2)) / 2.0;
+                // odd
+                } else {
+                    result = Math.max(left1, left2);
+                }
+                break;
+            } 
+            // partition is wrong (update left/right pointers)
+            else if (left1 > right2) {
+                right = i - 1;
+            } else {
+                left = i + 1;
+            }
+        }
+        
+        return result;
+    }
+}