Completed Trees-1

Leetcode105.java

@@ -0,0 +1,59 @@
+/**
+ * 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 {
+    Map<Integer, Integer> map;
+    int idx;
+
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        this.map = new HashMap<>();
+        this.idx = 0;
+        for (int i = 0; i < preorder.length; i++) {
+            this.map.put(inorder[i], i);
+        }
+        return helper(preorder, 0, preorder.length - 1);
+        // return null;
+
+    }
+
+    private TreeNode helper(int[] preorder, int start, int end) {
+        // Base
+        if (start > end)
+            return null; // When leaf node is reached.
+
+        // Logic
+        int val = preorder[idx]; // get value from the preorder index
+        idx++; // increment index so we fetch next element from the preorder
+        TreeNode node = new TreeNode(val); // add to a node
+        int rootIdx = map.get(val); // get the root index to get value of next root from the map.
+
+        // Left Subtree start and end positions
+        int leftStart = start;
+        int leftEnd = rootIdx - 1;
+
+        // Right Sub Tree start and end positions
+        int rightStart = rootIdx + 1;
+        int rightEnd = end;
+
+        // Left
+        node.left = helper(preorder, leftStart, leftEnd);
+
+        // Right
+        node.right = helper(preorder, rightStart, end);
+
+        return node;
+
+    }
+}

Leetcode98.java

@@ -0,0 +1,123 @@
+// TC : O(n)
+// SC : O(1)
+/**
+ * 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;
+ * }
+ * }
+ */
+// Solution 1 -> Having global Prev node.
+
+// class Solution {
+// TreeNode prev;
+// boolean breach;
+// public boolean isValidBST(TreeNode root) {
+// this.breach = false;
+// helper(root);
+
+// return !breach;
+// }
+
+// private void helper(TreeNode node) {
+// //Base case
+// if(node == null) return;
+
+// //Left
+// helper(node.left);
+
+// //Parent
+// if(prev != null && node.val <= prev.val) {
+// breach = true;
+// return;
+// }
+// prev = node;
+
+// //Right
+// helper(node.right);
+
+// }
+// }
+
+// Solution 2 - Maintaining a range
+// TC - O(n)
+// SC - O(1)
+// class Solution {
+
+// boolean breach;
+// public boolean isValidBST(TreeNode root) {
+// this.breach = false;
+// breach = helper(root, null, null);
+
+// return !breach;
+// }
+
+// private boolean helper(TreeNode node, Integer min, Integer max) {
+
+// //Base case
+// if(node == null) return false;
+
+// //Left
+// helper(node.left, min, node.val);
+
+// //Parent
+// if(( min != null && node.val <= min) || ( max != null && node.val >= max)) {
+// breach = true;
+// return breach;
+// }
+
+// //Right
+// helper(node.right, node.val, max);
+
+// return breach;
+
+// }
+// }
+
+// Solution 3 - Just checking prev node value at inorder and postorder level
+// TC - O(n)
+// SC - O(1)
+class Solution {
+    TreeNode prev;
+    boolean breach;
+
+    public boolean isValidBST(TreeNode root) {
+        this.breach = false;
+        helper(root);
+
+        return !breach;
+    }
+
+    private void helper(TreeNode node) {
+        // Base case
+        if (node == null)
+            return;
+
+        // Left
+        helper(node.left);
+
+        // Parent
+        if (prev != null && node.val <= prev.val) {
+            breach = true;
+            return;
+        }
+        prev = node;
+
+        // Right
+        helper(node.right);
+
+        if (prev != null && node.val > prev.val) {
+            breach = true;
+            return;
+        }
+
+    }
+}