Added tree, binary tree, dfs

Author: Prashant Jain

src/in/knowledgegate/dsa/binarysearchtree/SearchInBST.java

@@ -0,0 +1,46 @@
+package in.knowledgegate.dsa.binarysearchtree;
+
+import in.knowledgegate.dsa.binarytree.model.TreeNode;
+
+/**
+ * You are given the root of a binary search tree
+ * (BST) and an integer val.
+ *
+ * Find the node in the BST that the node's value
+ * equals val and return the subtree rooted with
+ * that node. If such a node does not exist,
+ * return null.
+ *
+ * Example 1:
+ *         4
+ *      2     7
+ *    1   3 X   X
+ * Input: root = [4,2,7,1,3], val = 2
+ * Output: [2,1,3]
+ *
+ * Example 2:
+ *         4
+ *      2     7
+ *    1   3 X   X
+ * Input: root = [4,2,7,1,3], val = 5
+ * Output: []
+ *
+ *
+ * Constraints:
+ *
+ * The number of nodes in the tree is in the
+ * range [1, 5000].
+ * 1 <= Node.val <= 107
+ * root is a binary search tree.
+ * 1 <= val <= 107
+ */
+public class SearchInBST {
+  public TreeNode searchBST(TreeNode root, int val) {
+    if (root == null) return null;
+    if (root.val == val) return root;
+    if (root.val < val) {
+      return searchBST(root.right, val);
+    }
+    return searchBST(root.left, val);
+  }
+}

src/in/knowledgegate/dsa/binarytree/InorderTraversalIterative.java

@@ -0,0 +1,30 @@
+package in.knowledgegate.dsa.binarytree;
+
+import in.knowledgegate.dsa.binarytree.model.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/**
+ * Write Inorder traversal of a binary tree using
+ * recursive approach
+ */
+public class InorderTraversalIterative {
+  public List<Integer> inorderTraversal(TreeNode root) {
+    Stack<TreeNode> stack = new Stack<>();
+    List<Integer> result = new ArrayList<>();
+    TreeNode curr = root;
+
+    while (curr != null || !stack.isEmpty()) {
+      while (curr != null) {
+        stack.push(curr);
+        curr = curr.left;
+      }
+      curr = stack.pop();
+      result.add(curr.val);
+      curr = curr.right;
+    }
+    return result;
+  }
+}

src/in/knowledgegate/dsa/binarytree/InorderTraversalRecursive.java

@@ -0,0 +1,25 @@
+package in.knowledgegate.dsa.binarytree;
+
+import in.knowledgegate.dsa.binarytree.model.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Write Inorder traversal of a binary tree using
+ * recursive approach
+ */
+public class InorderTraversalRecursive {
+  public List<Integer> inorderTraversal(TreeNode root) {
+    List<Integer> result = new ArrayList<>();
+    inorderTraversal(root, result);
+    return result;
+  }
+  private void inorderTraversal(TreeNode root,
+      List<Integer> result) {
+    if (root == null) return;
+    inorderTraversal(root.left, result);
+    result.add(root.val);
+    inorderTraversal(root.right, result);
+  }
+}

src/in/knowledgegate/dsa/binarytree/model/TreeNode.java

@@ -0,0 +1,14 @@
+package in.knowledgegate.dsa.binarytree.model;
+
+public class TreeNode {
+  public int val;
+  public TreeNode left;
+  public 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;
+  }
+}

src/in/knowledgegate/dsa/dfs/PathSum.java

@@ -0,0 +1,53 @@
+package in.knowledgegate.dsa.dfs;
+
+import in.knowledgegate.dsa.binarytree.model.TreeNode;
+
+/**
+ * Given the root of a binary tree and an integer
+ * targetSum, return true if the tree has a
+ * root-to-leaf path such that adding up all
+ * the values along the path equals targetSum.
+ *
+ * A leaf is a node with no children.
+ *
+ * Example 1:
+ *      1
+ *    2   3
+ *
+ * Input: root = [1,2,3], targetSum = 5
+ * Output: false
+ * Explanation: There two root-to-leaf paths in the tree:
+ * (1 --> 2): The sum is 3.
+ * (1 --> 3): The sum is 4.
+ * There is no root-to-leaf path with sum = 5.
+ *
+ * Input: root = [1,2,3], targetSum = 3
+ * Output: true
+ *
+ * Example 2:
+ * Input: root = [], targetSum = 0
+ * Output: false
+ * Explanation: Since the tree is empty, there
+ * are no root-to-leaf paths.
+ *
+ *
+ * Constraints:
+ * The number of nodes in the tree is in the
+ * range [0, 5000].
+ * -1000 <= Node.val <= 1000
+ * -1000 <= targetSum <= 1000
+ */
+public class PathSum {
+  public boolean hasPathSum(TreeNode root, int targetSum) {
+    if (root == null) return false;
+    if (root.val == targetSum && isLeaf(root)) return true;
+    int newTargetSum = targetSum - root.val;
+    return hasPathSum(root.left, newTargetSum) ||
+        hasPathSum(root.right, newTargetSum);
+  }
+
+  private boolean isLeaf(TreeNode node) {
+    return node != null && node.left == null
+        && node.right == null;
+  }
+}