code is Added

Author: anjha1

0106.construct-binary-tree-from-inorder-and-postorder-traversal/ConstructBinaryTreeFromInorderAndPostorderTraversal.java

@@ -0,0 +1,52 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 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 ConstructBinaryTreeFromInorderAndPostorderTraversal {
+    int postIndex;
+    int[] postorder;
+    int[] inorder;
+    Map<Integer, Integer> indexMap = new HashMap<>();
+
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        this.inorder = inorder;
+        this.postorder = postorder;
+        postIndex = postorder.length - 1;
+
+        int index = 0;
+        for (Integer val : inorder) {
+            indexMap.put(val, index++);
+        }
+
+        return helper(0, inorder.length - 1);
+    }
+
+    private TreeNode helper(int leftIndex, int rightIndex) {
+        if (leftIndex > rightIndex) {
+            return null;
+        }
+
+        int rootVal = postorder[postIndex];
+        TreeNode root = new TreeNode(rootVal);
+        int index = indexMap.get(rootVal);
+
+        postIndex--;
+        root.right = helper(index + 1, rightIndex);
+        root.left = helper(leftIndex, index - 1);
+        return root;
+    }
+}

0106.construct-binary-tree-from-inorder-and-postorder-traversal/README.md

@@ -0,0 +1,3 @@
+# [106. Construct Binary Tree from Inorder and Postorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)
+
+

0108.convert-sorted-array-to-binary-search-tree/ConvertSortedArrayToBinarySearchTree.java

@@ -0,0 +1,29 @@
+/**
+ * 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 ConvertSortedArrayToBinarySearchTree {
+    private TreeNode toBST(int[] nums, int sIdx, int eIdx) {
+        if (sIdx > eIdx) return null;
+        int mIdx = (sIdx + eIdx) / 2;
+        TreeNode root = new TreeNode(nums[mIdx]);
+        root.left = toBST(nums, sIdx, mIdx - 1);
+        root.right = toBST(nums, mIdx + 1, eIdx);
+        return root;
+    }
+
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return toBST(nums, 0, nums.length - 1);
+    }
+}

0108.convert-sorted-array-to-binary-search-tree/README.md

@@ -0,0 +1,2 @@
+# [108. Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/)
+

0109.convert-sorted-list-to-binary-search-tree/ConvertSortedListToBinarySearchTree.java

@@ -0,0 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+/**
+ * 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 ConvertSortedListToBinarySearchTree {
+    private ListNode preMid(ListNode head) {
+        ListNode slow = head, fast = head.next, pre = head;
+        while (fast != null && fast.next != null) {
+            pre = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return pre;
+    }
+
+    public TreeNode sortedListToBST(ListNode head) {
+        if (head == null) return null;
+        if (head.next == null) return new TreeNode(head.val);
+        ListNode preMid = preMid(head);
+        ListNode mid = preMid.next;
+        preMid.next = null;
+        TreeNode t = new TreeNode(mid.val);
+        t.left = sortedListToBST(head);
+        t.right = sortedListToBST(mid.next);
+        return t;
+    }
+}

0109.convert-sorted-list-to-binary-search-tree/README.md

@@ -0,0 +1,2 @@
+# [109. Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/)
+

0110.balanced-binary-tree/BalancedBinaryTree.java

@@ -0,0 +1,31 @@
+/**
+ * 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 BalancedBinaryTree {
+    private boolean result = true;
+
+    private int maxDepth(TreeNode root) {
+        if (root == null) return 0;
+        int l = maxDepth(root.left);
+        int r = maxDepth(root.right);
+        if (Math.abs(l - r) > 1) result = false;
+        return Math.max(l, r) + 1;
+    }
+
+    public boolean isBalanced(TreeNode root) {
+        maxDepth(root);
+        return result;
+    }
+}

0110.balanced-binary-tree/README.md

@@ -0,0 +1,2 @@
+# [110. Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/)
+

0111.minimum-depth-of-binary-tree/MinimumDepthOfBinaryTree.java

@@ -0,0 +1,24 @@
+/**
+ * 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 MinimumDepthOfBinaryTree {
+    public int minDepth(TreeNode root) {
+        if (root == null) return 0;
+        int left = minDepth(root.left);
+        int right = minDepth(root.right);
+        if (left == 0 || right == 0) return left + right + 1;
+        return Math.min(left, right) + 1;
+    }
+}

0111.minimum-depth-of-binary-tree/README.md

@@ -0,0 +1,2 @@
+# [111. Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/)
+

0112.path-sum/PathSum.java

@@ -0,0 +1,22 @@
+/**
+ * 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 PathSum {
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        if (root == null) return false;
+        if (root.left == null && root.right == null && root.val == targetSum) return true;
+        return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
+    }
+}

0112.path-sum/README.md

@@ -0,0 +1,2 @@
+# [112. Path Sum](https://leetcode.com/problems/path-sum/)
+

0113.path-sum-ii/PathSumIi.java

@@ -0,0 +1,38 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 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 PathSumIi {
+    private void pathSum(TreeNode root, int sum, List<Integer> sol, List<List<Integer>> res) {
+        if (root == null) return;
+        sol.add(root.val);
+        if (root.left == null && root.right == null && sum == root.val) {
+            res.add(new ArrayList<>(sol));
+        } else {
+            pathSum(root.left, sum - root.val, sol, res);
+            pathSum(root.right, sum - root.val, sol, res);
+        }
+
+        sol.remove(sol.size() - 1);
+    }
+
+    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
+        List<List<Integer>> res = new ArrayList<>();
+        pathSum(root, targetSum, new ArrayList<>(), res);
+        return res;
+    }
+}

0113.path-sum-ii/README.md

@@ -0,0 +1,2 @@
+# [113. Path Sum II](https://leetcode.com/problems/path-sum-ii/)
+

0114.flatten-binary-tree-to-linked-list/FlattenBinaryTreeToLinkedList.java

@@ -0,0 +1,27 @@
+/**
+ * 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 FlattenBinaryTreeToLinkedList {
+    TreeNode prev = null;
+
+    public void flatten(TreeNode root) {
+        if (root == null) return;
+        flatten(root.right);
+        flatten(root.left);
+        root.left = null;
+        root.right = prev;
+        prev = root;
+    }
+}

0114.flatten-binary-tree-to-linked-list/README.md

@@ -0,0 +1,2 @@
+# [114. Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/)
+

0116.populating-next-right-pointers-in-each-node/PopulatingNextRightPointersInEachNode.java

@@ -0,0 +1,33 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {}
+    
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class PopulatingNextRightPointersInEachNode {
+    public NextNode connect(NextNode root) {
+        if (root == null) return null;
+        if (root.left != null) root.left.next = root.right;
+        if (root.right != null && root.next != null) root.right.next = root.next.left;
+        connect(root.left);
+        connect(root.right);
+        return root;
+    }
+}

0116.populating-next-right-pointers-in-each-node/README.md

@@ -0,0 +1,2 @@
+# [116. Populating Next Right Pointers in Each Node](https://leetcode.com/problems/populating-next-right-pointers-in-each-node/)
+

0117.populating-next-right-pointers-in-each-node-ii/PopulatingNextRightPointersInEachNodeIi.java

@@ -0,0 +1,47 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {}
+    
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+    public Node connect(Node root) {
+        Node dummyHead = new Node(0);
+        Node pre = dummyHead;
+        Node res = root;
+        while (root != null) {
+            if (root.left != null) {
+                pre.next = root.left;
+                pre = pre.next;
+            }
+            if (root.right != null) {
+                pre.next = root.right;
+                pre = pre.next;
+            }
+            root = root.next;
+            if (root == null) {
+                pre = dummyHead;
+                root = dummyHead.next;
+                dummyHead.next = null;
+            }
+        }
+        return res;
+    }
+}