#Modification 22

Author: amangit1314

…clipse_ide/binaryTree/BT_Problem_01.java binaryTree/BT_Problem_01.javadata_from_eclipse_ide/binaryTree/BT_Problem_01.java renamed to binaryTree/BT_Problem_01.java data_from_eclipse_ide/binaryTree/BT_Problem_01.java renamed to binaryTree/BT_Problem_01.java

@@ -0,0 +1,92 @@
+package binaryTree;
+import java.util.*;
+
+// Find Reverse Level Order traversal
+
+public class BT_Problem_02 {
+
+	Node root;
+	
+	/* Given a binary tree, print its nodes in reverse level order */
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	void reverseLevelOrder(Node node) {
+		
+		//Logic for O(n^2) Time Complexity approach 
+//		int h = height(node);
+//		int i;
+//		for(i = h; i >= 1; i--)
+//			printGivenLevel(node, i);
+		
+		Stack<Node> S = new Stack();
+		Queue<Node> Q = new LinkedList();
+		Q.add(node);
+		
+		// Do something like normal level order traversal order.
+		// Following are the differences with normal level order traversal:
+		// 1. Instead of printing a node, we push the node to stack 
+		// 2. Right subtree is visited before left subtree.
+		while(Q.isEmpty() == false) {
+			
+			//Dequeue node and make it root
+			node = Q.peek();
+			Q.remove();
+			S.push(node);
+			
+			//Enqueue right child
+			if(node.right != null)
+				Q.add(node.right);	//Node RIGHT CHILD IS ENQUEUED BEFORE LEFT
+			
+			// Enqueue left child 
+			if(node.left != null)
+				Q.add(node.left);
+		}
+		
+		// Now pop all items from stack one by one and print them
+		while(S.empty() == false) {
+			node = S.peek();
+			System.out.print(node.data + " ");
+			S.pop();
+		}
+		
+	}
+	
+//	void printGivenLevel(Node node, int level) {
+//		if(node == null)
+//			return;
+//		if(level == 1)
+//			System.out.print(node.data + " ");
+//		else if(level > 1) {
+//			printGivenLevel(node.left, level - 1);
+//			printGivenLevel(node.right, level - 1);
+//		}
+//	}
+//	
+//	int height(Node node) {
+//		if(node == null)
+//			return 0;
+//		else {
+//			int lheight = height(node.left);
+//			int rheight = height(node.right);
+//			
+//			if(lheight > rheight)
+//				return (lheight + 1);
+//			else
+//				return (rheight + 1);
+//		}
+//	}
+//	
+	public static void main(String[] args) {
+		
+		BT_Problem_02 tree = new BT_Problem_02();
+		
+		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.reverseLevelOrder(tree.root);
+	}
+}

binaryTree/BT_Problem_02.java

@@ -0,0 +1,50 @@
+package binaryTree;
+
+/*	Problem Title :- Find the Height of a tree or Maximum Depth of a tree.
+ * 
+ *  Height of tree :- 
+ *  The height of a tree is the number of edges on the longest downward path
+ *  between the root and a leaf.
+ */
+public class BT_Problem_03 {
+
+	Node root;
+	
+	/* 
+	 * Compute the "maxDepth" of a tree -- 
+	 * the number of nodes along the longest path from the root node
+	 * down to the farthest leaf node
+	 */
+	int maxDepth(Node node) {
+		
+		if(node == null)	return 0;
+		
+		else {
+			/* compute the depth of each subtree */
+			int lDepth = maxDepth(node.left);
+			int rDepth = maxDepth(node.right);
+			
+			/* use the larger one*/
+			if(lDepth > rDepth)
+				return (lDepth + 1);
+			else
+				return (rDepth + 1);
+		}
+	}
+	
+	/* Driver program to test above functions */
+	public static void main(String[] args) {
+
+		BT_Problem_03 tree = new BT_Problem_03();
+		
+		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("Height of tree is : " + tree.maxDepth(tree.root));
+
+	}
+
+}

binaryTree/BT_Problem_03.java

@@ -0,0 +1,61 @@
+package binaryTree;
+/*	Problem Title :- Find the Diameter of a tree or Width of tree.
+ * 
+ *  Diameter of a tree :- 
+ *  The Diameter of a tree is the number of nodes on the longest path
+ *  between two end nodes.
+ */
+
+// Class to print the Diameter.
+public class BT_Problem_04 {
+
+	Node root;
+	
+	// Method to calculate the diameter and return it to main
+	int diameter(Node root) {
+		// base case if tree is empty
+		if(root == null)
+			return 0;
+		
+		// get the height of left and right sub-trees
+		int lheight = height(root.left);
+		int rheight = height(root.right);
+		
+		// get the diameter of left and right sub-trees
+		int ldiameter = diameter(root.left);
+		int rdiameter = diameter(root.right);
+		
+		return Math.max(lheight + rheight + 1, Math.max(ldiameter, rdiameter));
+	}
+	
+	// A wrapper over diameter(Node root)
+	int diameter() {return diameter(root);}
+	
+	/*
+	 * The function Compute the "height" of a tree.
+	 * Height is the number of nodes along the longest path 
+	 * from the root node to the farthest leaf node.
+	 */
+	static int height(Node node) {
+		if(node == null)
+			return 0;
+		// If tree is not empty then height = 1 + max of left height and right heights.
+		return (1 + Math.max(height(node.left), height(node.left)));
+	}
+	
+	// Driver Code
+	public static void main(String[] args) {
+		
+		BT_Problem_04 tree = new BT_Problem_04();
+		
+		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);
+		
+		// Function Call
+		System.out.println("The diameter of given bianry tree is : " + tree.diameter());
+	}
+
+}

binaryTree/BT_Problem_04.java

@@ -0,0 +1,84 @@
+package binaryTree;
+
+/*	Problem Title :- Find Mirror of a tree.
+ * 
+ *  Mirror of a tree :- 
+ *  The Diameter of a tree is the number of nodes on the longest path
+ *  between two end nodes.
+ */
+public class BT_Problem_05 {
+
+	/*
+	 * A binary tree node has data, 
+	 * pointer to left child 
+	 * & a pointer to right child
+	 */
+	static class node{
+		int val;
+		node left;
+		node right;
+	}
+	
+	/*
+	 * Helper function that allocates a new node with the given data
+	 * & null left and right pointers
+	 */
+	static node createNode(int val) {
+		node newNode = new node();
+		newNode.val = val;
+		newNode.left = null;
+		newNode.right = null;
+		return newNode;
+	}
+	
+	/*
+	 * Helper function to print
+	 * In-order Traversal
+	 */
+	static void inorder(node root) {
+		if(root == null)
+			return;
+		inorder(root.left);
+		System.out.println(root.val);
+		inorder(root.right);
+	}
+	
+	/*
+	 * mirror-i-f-y function takes two trees,
+	 * original tree and a mirror tree
+	 * It recurses on both the trees.
+	 * but when original tree recurses on left,
+	 * mirror tree recurses on right and vice-versa
+	 */
+	static node mirrorify(node root) {
+		if(root == null)
+			return null;
+		
+		// Create new mirror node from original tree node
+		node mirror = createNode(root.val);
+		mirror.right = mirrorify(root.left);
+		mirror.left = mirrorify(root.right);
+		return mirror;
+	}
+	
+	// Driver Code
+	public static void main(String[] args) {
+
+		node tree = createNode(5);
+		tree.left = createNode(5);
+		tree.right = createNode(5);
+		tree.left.right = createNode(5);
+		tree.left.left = createNode(5);
+		
+		// print in-order traversal of the original input tree
+		System.out.print("\n Inorderr of original tree: ");
+		inorder(tree);
+		node mirror = null;
+		mirror = mirrorify(tree);
+		
+		// print in-order traversal of the mirror tree
+		System.out.print("\n Inorderr of mirror tree: ");
+		inorder(mirror);
+	}
+
+}

binaryTree/BT_Problem_05.java

@@ -0,0 +1,62 @@
+package binaryTree;
+import java.util.*;
+/*	
+ * Problem Title :- In-order Traversal of a tree both using Recursion
+ */
+// Class to print the in-order traversal
+public class BT_Problem_06_a {
+
+		// Root of Binary Tree
+		Node root;
+		
+		/*
+		 * Given a binary tree,
+		 * print its nodes in in-order
+		 */
+		void inorder() {
+			
+			if(root == null)	return;
+			
+			Stack<Node> s = new Stack<>();
+			Node curr = root;
+			
+			// traverse the tree
+			while(curr != null || s.size() > 0) {
+				/* Reach the left most Node of the current Node */
+				while(curr != null) {
+					/* place pointer to a tree node on 
+					 * the stack before traversing
+					 * the node,s left subtree */
+					s.push(curr);
+					curr = curr.left;
+				}
+				
+				/*Current must be NULL at this point */
+				curr = s.pop();
+				
+				System.out.print(curr.data + " ");
+				
+				/* we have visited the node and its left subtree.
+				 * Now, its right subtree's turn */
+				curr = curr.right;
+			}
+		}
+		
+		// Driver method
+		public static void main(String[] args) {
+
+			// creating a binary tree and entering the nodes
+			BT_Problem_06_a tree = new BT_Problem_06_a();
+			
+			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);
+			
+			tree.inorder();
+						
+		}
+
+}
+