diff --git a/data_structures/Trees/Level Order Traversal(using Queue).java b/data_structures/Trees/Level Order Traversal(using Queue).java new file mode 100644 index 000000000000..4f263c95a882 --- /dev/null +++ b/data_structures/Trees/Level Order Traversal(using Queue).java @@ -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 queue = new LinkedList(); + 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(); + } +} \ No newline at end of file diff --git a/data_structures/Trees/Level Order Traversal.java b/data_structures/Trees/Level Order Traversal.java new file mode 100644 index 000000000000..845ab3760e13 --- /dev/null +++ b/data_structures/Trees/Level Order Traversal.java @@ -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(); + } +} \ No newline at end of file diff --git a/data_structures/Trees/Print Top View of Tree.java b/data_structures/Trees/Print Top View of Tree.java new file mode 100644 index 000000000000..a429f8a6fd93 --- /dev/null +++ b/data_structures/Trees/Print Top View of Tree.java @@ -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 set = new HashSet<>(); + + // Create a queue and add root to it + Queue Q = new LinkedList(); + 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(); + } +} \ No newline at end of file diff --git a/data_structures/Trees/Valid BST or not.java b/data_structures/Trees/Valid BST or not.java new file mode 100644 index 000000000000..0f71a46a0d14 --- /dev/null +++ b/data_structures/Trees/Valid BST or not.java @@ -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"); + } +} \ No newline at end of file