update

Author: Blooverh

LeetCode/Grind169/BinarySearch/BinarySearch_704.java

@@ -0,0 +1,29 @@
+package Grind169.BinarySearch;
+
+public class BinarySearch_704 {
+    public static void main(String[] args) {
+        int nums[]={-1,0,3,5,9,12};
+        int target=9;
+
+        System.out.println(search(nums, target));
+    }
+
+    public static int search(int[] nums, int target) {
+        int low=0;
+        int high= nums.length-1;
+
+        while(low <= high){
+            int mid=(low+high)/2;
+            if(nums[mid] > target){
+                high=mid-1;
+            }else if(nums[mid] == target){
+                return mid;
+            }else{
+                low=mid+1;
+            }
+
+        }
+
+        return -1;
+    }
+}

LeetCode/Grind169/BinaryTrees/InvertBinaryTree_226.java

@@ -1,7 +1,6 @@
 package Grind169.BinaryTrees;
 
 public class InvertBinaryTree_226 {
-
 
     class TreeNode {
         int val;

LeetCode/Grind169/BinaryTrees/SameTree_100.java

@@ -0,0 +1,39 @@
+package Grind169.BinaryTrees;
+
+public class SameTree_100 {
+    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;
+        }
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        // If both root nodes p and q are null tree is true 
+        if(p==null && q== null){
+            return true;
+        }
+
+        //if one root is not null and the other root is null they are not the same tree thus false
+        if(p== null && q != null || p!=null && q==null){
+            return false;
+        }
+
+        // if both nodes do not have the same value then return false
+        if(p.val != q.val){
+            return false;
+        }
+        // recursive call for both left nodes of each root node and right node of each root
+        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+    }
+}

LeetCode/Grind169/BinaryTrees/SubtreeOfAnotherTree_572.java

@@ -0,0 +1,45 @@
+package Grind169.BinaryTrees;
+
+public class SubtreeOfAnotherTree_572 {
+    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;
+        }
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+     /**
+   * Time O(n)
+   * Space O(h)
+   */
+  public boolean isSubtree(TreeNode root, TreeNode subRoot) {
+    if (root == null) return false;
+    if (dfs(root, subRoot)) return true;
+    return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
+  }
+
+  /**
+   * Time O(n)
+   * Space O(h)
+   *   - Each element costs constant space O(1).
+   *     And the size of the stack is exactly the depth of DFS.
+   *     So in the worst case, it costs O(h) to maintain the system stack,
+   *     where h is the maximum depth of DFS.
+   */
+  public boolean dfs(TreeNode root, TreeNode subRoot) {
+    if (root == null && subRoot == null) return true;
+    if (root == null || subRoot == null) return false;
+    if (root.val != subRoot.val) return false;
+    return dfs(root.left, subRoot.left) && dfs(root.right, subRoot.right);
+  }
+}

LeetCode/Grind169/BinaryTrees/SymmetricTree_101.java

@@ -0,0 +1,39 @@
+package Grind169.BinaryTrees;
+
+public class SymmetricTree_101 {
+    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;
+        }
+    }
+
+    public static void main(String[] args) {
+        
+    }
+
+    //helper method 
+    public boolean isSymmetric(TreeNode root) {
+        //if root is null than there is no tree hence not symmetric
+        if(root == null){ return false;}
+        // check whether next nodes are equal
+        return  checkSymmetric(root.left, root.right); 
+    }
+
+    public boolean checkSymmetric(TreeNode leftParent, TreeNode rightParent){
+        //checks whether nodes are both null or one is null anf other not
+        if(leftParent == null && rightParent == null){return true;}
+        if(leftParent == null || rightParent == null){return false;}
+        //check whether the value of each node is not equal
+        if(leftParent.val != rightParent.val){return false;}
+
+        return checkSymmetric(leftParent.left, rightParent.right) && checkSymmetric(leftParent.right, rightParent.left);
+
+    }
+}