Tree Problems

Author: abhiabhi

src/main/java/com/tree/BFSorLevelOrderTraversalOfBinaryTree.java

@@ -0,0 +1,57 @@
+package com.tree;
+
+import com.tree.model.TreeNode;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * printLevelorder(tree)
+ * 1) Create an empty queue q
+ * 2) temp_node = root /*start from root
+ * 3)Loop while temp_node is not NULL
+         *a)print temp_node->data.
+         *b)Enqueue temp_node’s children(first left then right children)to q
+         *c)Dequeue a node from q and assign it’s value to temp_node
+ */
+public class BFSorLevelOrderTraversalOfBinaryTree {
+
+    public static void main(String[] args) {
+        /*
+            Binary Tree
+
+                1
+               / \
+              2   3
+             / \
+            4   5
+         */
+        TreeNode tree = new TreeNode(1);
+        tree.left = new TreeNode(2);
+        tree.right = new TreeNode(3);
+        tree.left.left = new TreeNode(4);
+        tree.left.right = new TreeNode(5);
+
+        bfsOrlevelOrderTraversal(tree);
+
+    }
+
+    private static void bfsOrlevelOrderTraversal(TreeNode tree) {
+
+        if (tree == null) {
+            return;
+        }
+        Queue<TreeNode> queue = new LinkedList();
+        queue.offer(tree);
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll();
+            System.out.println(node.val);
+            if (node.left != null) {
+                queue.offer(node.left);
+            }
+            if (node.right != null) {
+                queue.offer(node.right);
+            }
+        }
+    }
+}

src/main/java/com/tree/BinaryTreeZigZagLevelOrderTraversal.html

@@ -0,0 +1,117 @@
+package com.tree;
+
+import com.tree.model.TreeNode;
+
+import java.util.*;
+
+/**
+ * Description:
+ * Given a binary tree, return the zigzag level order traversal of its TreeNodes' values. (ie, from left to right, then
+ * right to left for the next level and alternate between).
+ *
+ * For example:
+ * Given binary tree [3,9,20,null,null,15,7],
+ *     3
+ *    / \
+ *   9  20
+ *     /  \
+ *    15   7
+ * return its zigzag level order traversal as:
+ * [
+ *   [3],
+ *   [20,9],
+ *   [15,7]
+ * ]
+ *
+ * Algorithm
+ * 1.  Take 2 Stack, one for current level and one for next level.
+ *
+ *
+ * 2.  For filling the next Level stack, we have to see whether it need to be filled Left to Right or Right
+ *      to left as we are reading the Level Order spirally.
+ * 3.  When we are reading current level stack, all the children's of current level stack will go to next
+ *      level stack.
+ * 4.  When current level stack has no value and is Empty at that time point current level stack
+ *      reference to hold next level stack values, that is current level stack will now point to next level
+ *      stack and next level stack should be reinitialize for its next level.
+ *      Also, this is the time when we need to alter our reading style for childrens that is it need to be
+ *      read in left - right fashion.
+ *
+ */
+
+public class BinaryTreeZigZagLevelOrderTraversal {
+
+    /**
+     * Time Complexity:
+     * Space Complexity:
+     * Runtime: <a href="https://leetcode.com/submissions/detail/250830618/">1 ms</a>.
+     *
+     * @param rootTreeNode
+     * @return
+     */
+    public static void zigZagTraverse(TreeNode rootTreeNode) {
+
+            // Base case
+            if(rootTreeNode==null){
+                return;
+            }
+
+            Stack<TreeNode> currentLevelStack = new Stack<TreeNode>();
+            Stack<TreeNode> nextLevelStack = new Stack<TreeNode>();
+
+            boolean isLeftRightReading = true;
+            currentLevelStack.add(rootTreeNode);
+
+            while(!currentLevelStack.isEmpty()){
+                TreeNode n = currentLevelStack.pop();
+                System.out.print(n.val+ " ");
+
+                if(isLeftRightReading){
+
+                    if(n.left!=null)
+                        nextLevelStack.push(n.left);
+
+                    if(n.right!=null)
+                        nextLevelStack.push(n.right);
+
+                }else{
+                    if(n.right!=null)
+                        nextLevelStack.push(n.right);
+
+                    if(n.left!=null)
+                        nextLevelStack.push(n.left);
+
+                }
+
+                if(currentLevelStack.isEmpty()){
+                    isLeftRightReading = !isLeftRightReading;
+                    currentLevelStack=nextLevelStack;
+                    nextLevelStack = new Stack<TreeNode>();
+                }
+
+            }
+        }
+
+
+    public static void main(String[] args) {
+        /*
+            Binary Tree
+
+                1
+               / \
+              2   3
+             / \
+            4   5
+         */
+        TreeNode tree = new TreeNode(1);
+        tree.left = new TreeNode(2);
+        tree.right = new TreeNode(3);
+        tree.left.left = new TreeNode(4);
+        tree.left.right = new TreeNode(5);
+
+        zigZagTraverse(tree);
+
+    }
+}
+
+

src/main/java/com/tree/BinaryTreeZigZagLevelOrderTraversal.java

@@ -0,0 +1,53 @@
+package com.tree;
+
+import com.tree.model.TreeNode;
+
+public class CheckBinaryTreeIsBST {
+
+    public static void main(String args[]) {
+
+    /*
+          Binary Tree
+
+              1
+             / \
+            2   3
+           / \
+          4   5
+       */
+        TreeNode tree = new TreeNode(10);
+        tree.left = new TreeNode(8);
+        tree.right = new TreeNode(30);
+        tree.left.left = new TreeNode(6);
+        tree.left.right = new TreeNode(9);
+        tree.right.left = new TreeNode(15);
+        tree.right.right = new TreeNode(35);
+        tree.left.left.left = new TreeNode(4);
+
+
+        int min = Integer.MIN_VALUE;
+        int max = Integer.MAX_VALUE;
+
+        System.out.println("Is Binary Search Tree:" + isBST(tree,min,max));
+    }
+
+    /**Returns true if the given tree is a BST and its
+      values are >= min and <= max. */
+    private static boolean isBST(TreeNode node, int min, int max) {
+
+        /* an empty tree is BST */
+        if (node == null)
+            return true;
+
+        /**important*/
+        /** false if this node violates the min/max constraints */
+        if(node.val < min || node.val >max){
+            return false;
+        }
+
+         /** otherwise check the subtrees recursively
+        tightening the min/max constraints */
+        // Allow only distinct values
+        return isBST(node.left,min,node.val-1) && isBST(node.right, node.val+1, max);
+    }
+}

src/main/java/com/tree/CheckBinaryTreeIsBST.java

@@ -0,0 +1,81 @@
+package com.tree;
+
+
+import com.tree.model.TreeNode;
+
+import java.util.Stack;
+
+/**
+ * LEFT *ROOT* RIGHT
+ *
+ * It's worth remembering that the inOrder traversal is a depth-first algorithm and
+ * prints the tree node in sorted order if given binary tree is a binary search tree.
+ *
+ * Visit left node
+ * Print value of the root
+ * Visit right node
+ *
+ */
+public class DFSInorderTraversalOfTree {
+
+    public static void main (String args[]){
+       TreeNode root= create();
+       inOrderTraversal(root);
+        inorderStack(root);
+    }
+
+    /**
+     * Recurssive Approach
+     * @param root
+     */
+    private static void inOrderTraversal(TreeNode root) {
+        if (root == null){
+            return;
+        }
+        inOrderTraversal(root.left);
+        System.out.print(root.val + " ");
+        inOrderTraversal(root.right);
+    }
+
+    /**Iterative Approach*/
+    public static void inorderStack(TreeNode root)
+    {
+        Stack<TreeNode> s =new Stack<TreeNode>();
+        while(true){
+
+            // Go to the left extreme insert all the elements to stack
+            while(root != null){
+                s.push(root);
+                root = root.left;
+            }
+            // check if Stack is empty, if yes, exit from everywhere
+            if (s.isEmpty()) {
+                return;
+            }
+            // pop the element from the stack , print it and add the nodes at
+            // the right to the Stack
+            root =s.pop();
+            System.out.print(root.val + " ");
+            root = root.right;
+        }
+    }
+
+
+    /**
+     * Java method to create binary tree with test data
+     *
+     * @return a sample binary tree for testing
+     */
+    public static TreeNode create() {
+        TreeNode root = new TreeNode(40);
+        root.left = new TreeNode(20);
+        root.left.left = new TreeNode(10);
+        root.left.left.left = new TreeNode(5);
+        root.left.right = new TreeNode(30);
+        root.right = new TreeNode(50);
+        root.right.right = new TreeNode(60);
+        root.left.right.left = new TreeNode(67);
+        root.left.right.right = new TreeNode(78);
+        return root;
+    }
+}

src/main/java/com/tree/DFSInorderTraversalOfTree.java

@@ -0,0 +1,72 @@
+package com.tree;
+
+import com.tree.model.TreeNode;
+
+import java.util.Stack;
+
+/**
+ * *ROOT* LEFT RIGHT
+ */
+public class DFSPreOrderTraversalOfBinaryTree {
+
+    /**
+     * Recurssive Approach
+     *
+     * @param root
+     */
+    private static void preOrderTraversal(TreeNode root) {
+        if (root == null) {
+            return;
+        }
+        System.out.print(root.val + " ");
+        preOrderTraversal(root.left);
+        preOrderTraversal(root.right);
+    }
+
+    /**
+     * Iterative Approach
+     */
+    public static void preOrderStack(TreeNode root) {
+        Stack<TreeNode> s = new Stack<TreeNode>();
+
+        while (true) {
+            // First print the root node and then add left node
+            while (root != null) {
+                System.out.print(root.val + " ");
+                s.push(root);
+                root = root.left;
+            }
+            // check if Stack is emtpy, if yes, exit from everywhere
+            if (s.isEmpty()) {
+                return;
+            }
+            // pop the element from the stack and go right to the tree
+            root = s.pop();
+            root = root.right;
+        }
+    }
+
+
+    /**
+     * Java method to create binary tree with test data
+     *
+     * @return a sample binary tree for testing
+     */
+    public static TreeNode create() {
+        TreeNode root = new TreeNode(40);
+        root.left = new TreeNode(20);
+        root.left.left = new TreeNode(10);
+        root.left.left.left = new TreeNode(5);
+        root.left.right = new TreeNode(30);
+        root.right = new TreeNode(50);
+        root.right.right = new TreeNode(60);
+        root.left.right.left = new TreeNode(67);
+        root.left.right.right = new TreeNode(78);
+        return root;
+    }
+
+    public static void main(String args[]) {
+        TreeNode root = create();
+        preOrderStack(root);
+    }
+}