TheAlgorithms · dynamitechetan · Oct 13, 2017 · Sep 29, 2017 · Oct 10, 2017 · Oct 13, 2017
@@ -0,0 +1,62 @@
+import java.util.Queue;
+import java.util.LinkedList;
+
+/* Class to represent Tree node */
+class Node {
+    int data;
+    Node left, right;
+
+    public Node(int item) {
+        data = item;
+        left = null;
+        right = null;
+    }
+}
+
+/* Class to print Level Order Traversal */
+class BinaryTree {
+
+    Node root;
+
+    /* Given a binary tree. Print its nodes in level order
+     using array for implementing queue  */
+    void printLevelOrder() 
+    {
+        Queue<Node> queue = new LinkedList<Node>();
+        queue.add(root);
+        while (!queue.isEmpty()) 
+        {
+
+            /* poll() removes the present head.
+            For more information on poll() visit 
+            http://www.tutorialspoint.com/java/util/linkedlist_poll.htm */
+            Node tempNode = queue.poll();
+            System.out.print(tempNode.data + " ");
+
+            /*Enqueue left child */
+            if (tempNode.left != null) {
+                queue.add(tempNode.left);
+            }
+
+            /*Enqueue right child */
+            if (tempNode.right != null) {
+                queue.add(tempNode.right);
+            }
+        }
+    }
+
+    public static void main(String args[]) 
+    {
+        /* creating a binary tree and entering 
+         the nodes */
+        BinaryTree tree_level = new BinaryTree();
+        tree_level.root = new Node(1);
+        tree_level.root.left = new Node(2);
+        tree_level.root.right = new Node(3);
+        tree_level.root.left.left = new Node(4);
+        tree_level.root.left.right = new Node(5);
+
+        System.out.println("Level order traversal of binary tree is - ");
+        tree_level.printLevelOrder();
+    }
+}
@@ -0,0 +1,78 @@
+class Node
+{
+    int data;
+    Node left, right;
+    public Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}
+
+class BinaryTree
+{
+    // Root of the Binary Tree
+    Node root;
+
+    public BinaryTree()
+    {
+        root = null;
+    }
+
+    /* function to print level order traversal of tree*/
+    void printLevelOrder()
+    {
+        int h = height(root);
+        int i;
+        for (i=1; i<=h; i++)
+            printGivenLevel(root, i);
+    }
+
+    /* Compute the "height" of a tree -- the number of
+    nodes along the longest path from the root node
+    down to the farthest leaf node.*/
+    int height(Node root)
+    {
+        if (root == null)
+           return 0;
+        else
+        {
+            /* compute  height of each subtree */
+            int lheight = height(root.left);
+            int rheight = height(root.right);
+
+            /* use the larger one */
+            if (lheight > rheight)
+                return(lheight+1);
+            else return(rheight+1); 
+        }
+    }
+
+    /* Print nodes at the given level */
+    void printGivenLevel (Node root ,int level)
+    {
+        if (root == null)
+            return;
+        if (level == 1)
+            System.out.print(root.data + " ");
+        else if (level > 1)
+        {
+            printGivenLevel(root.left, level-1);
+            printGivenLevel(root.right, level-1);
+        }
+    }
+
+    /* Driver program to test above functions */
+    public static void main(String args[])
+    {
+       BinaryTree tree = new BinaryTree();
+       tree.root= new Node(1);
+       tree.root.left= new Node(2);
+       tree.root.right= new Node(3);
+       tree.root.left.left= new Node(4);
+       tree.root.left.right= new Node(5);
+
+       System.out.println("Level order traversal of binary tree is ");
+       tree.printLevelOrder();
+    }
+}
@@ -0,0 +1,105 @@
+// Java program to print top view of Binary tree
+import java.util.*;
+
+// Class for a tree node
+class TreeNode
+{
+    // Members
+    int key;
+    TreeNode left, right;
+
+    // Constructor
+    public TreeNode(int key)
+    {
+        this.key = key;
+        left = right = null;
+    }
+}
+
+// A class to represent a queue item. The queue is used to do Level
+// order traversal. Every Queue item contains node and horizontal
+// distance of node from root
+class QItem
+{
+   TreeNode node;
+   int hd;
+   public QItem(TreeNode n, int h)
+   {
+        node = n;
+        hd = h;
+   }
+}
+
+// Class for a Binary Tree
+class Tree
+{
+    TreeNode root;
+
+    // Constructors
+    public Tree()  { root = null; }
+    public Tree(TreeNode n) { root = n; }
+
+    // This method prints nodes in top view of binary tree
+    public void printTopView()
+    {
+        // base case
+        if (root == null) {  return;  }
+
+        // Creates an empty hashset
+        HashSet<Integer> set = new HashSet<>();
+
+        // Create a queue and add root to it
+        Queue<QItem> Q = new LinkedList<QItem>();
+        Q.add(new QItem(root, 0)); // Horizontal distance of root is 0
+
+        // Standard BFS or level order traversal loop
+        while (!Q.isEmpty())
+        {
+            // Remove the front item and get its details
+            QItem qi = Q.remove();
+            int hd = qi.hd;
+            TreeNode n = qi.node;
+
+            // If this is the first node at its horizontal distance,
+            // then this node is in top view
+            if (!set.contains(hd))
+            {
+                set.add(hd);
+                System.out.print(n.key + " ");
+            }
+
+            // Enqueue left and right children of current node
+            if (n.left != null)
+                Q.add(new QItem(n.left, hd-1));
+            if (n.right != null)
+                Q.add(new QItem(n.right, hd+1));
+        }
+    }
+}
+
+// Driver class to test above methods
+public class Main
+{
+    public static void main(String[] args)
+    {
+        /* Create following Binary Tree
+             1
+           /  \
+          2    3
+           \
+            4
+             \
+              5
+               \
+                6*/
+        TreeNode root = new TreeNode(1);
+        root.left = new TreeNode(2);
+        root.right = new TreeNode(3);
+        root.left.right = new TreeNode(4);
+        root.left.right.right = new TreeNode(5);
+        root.left.right.right.right = new TreeNode(6);
+        Tree t = new Tree(root);
+        System.out.println("Following are nodes in top view of Binary Tree");
+        t.printTopView();
+    }
+}
@@ -0,0 +1,62 @@
+class Node
+{
+    int data;
+    Node left, right;
+
+    public Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}
+
+public class BinaryTree
+{
+    //Root of the Binary Tree
+    Node root;
+
+    /* can give min and max value according to your code or
+    can write a function to find min and max value of tree. */
+
+    /* returns true if given search tree is binary
+     search tree (efficient version) */
+    boolean isBST()  {
+        return isBSTUtil(root, Integer.MIN_VALUE,
+                               Integer.MAX_VALUE);
+    }
+
+    /* Returns true if the given tree is a BST and its
+      values are >= min and <= max. */
+    boolean isBSTUtil(Node node, int min, int max)
+    {
+        /* an empty tree is BST */
+        if (node == null)
+            return true;
+
+        /* false if this node violates the min/max constraints */
+        if (node.data < min || node.data > max)
+            return false;
+
+        /* otherwise check the subtrees recursively
+        tightening the min/max constraints */
+        // Allow only distinct values
+        return (isBSTUtil(node.left, min, node.data-1) &&
+                isBSTUtil(node.right, node.data+1, max));
+    }
+
+    /* Driver program to test above functions */
+    public static void main(String args[])
+    {
+        BinaryTree tree = new BinaryTree();
+        tree.root = new Node(4);
+        tree.root.left = new Node(2);
+        tree.root.right = new Node(5);
+        tree.root.left.left = new Node(1);
+        tree.root.left.right = new Node(3);
+
+        if (tree.isBST())
+            System.out.println("IS BST");
+        else
+            System.out.println("Not a BST");
+    }
+}