Added code for important questions on Trees

Trees/AllKSumPath.java

@@ -0,0 +1,48 @@
+package Trees;
+
+import java.util.ArrayList;
+
+import Trees.BinaryTree.*;
+public class AllKSumPath {
+	public static void main(String[] args) {
+		BinaryTree tree = new BinaryTree();
+		tree.root = new TreeNode(1); 
+		tree.root.left = new TreeNode(3); 
+		tree.root.left.left = new TreeNode(2); 
+		tree.root.left.right = new TreeNode(1); 
+		tree.root.left.right.left = new TreeNode(1); 
+		tree.root.right = new TreeNode(-1); 
+		tree.root.right.left = new TreeNode(4); 
+		tree.root.right.left.left = new TreeNode(1); 
+		tree.root.right.left.right = new TreeNode(2); 
+		tree.root.right.right = new TreeNode(5); 
+		tree.root.right.right.right = new TreeNode(2); 
+		int k = 5; 
+		findK(tree.root, k);
+	}
+	static void findK(TreeNode root, int k){
+		if(root==null) return;
+		ArrayList<Integer> path = new ArrayList<>();
+		findkHelp(root, path, k);
+	}
+	static void findkHelp(TreeNode root, ArrayList<Integer> path, int k){
+		if(root==null) return;
+		path.add(root.val);
+		findkHelp(root.left, path, k);
+		findkHelp(root.right, path, k);
+		int f = 0;
+		//check at every node
+		for(int j=path.size()-1;j>=0;j--){
+			f+=path.get(j);
+			if(f==k) printk(path, j);
+		}
+		// backtraking
+		path.remove(path.size()-1);
+	}
+	static void printk(ArrayList<Integer> arr,int j){
+		for(int i=j;i<arr.size();i++){
+			System.out.print(arr.get(i)+" ");
+		}
+		System.out.println();
+	}
+}

Trees/BST/BST.java

@@ -0,0 +1,21 @@
+package Trees.BST;
+
+public class BST {
+	public BSTNode root;
+	public void insert(int data){
+		root = insertHelper(root, data);
+	}
+	private BSTNode insertHelper(BSTNode root,int data){
+		if(root==null){ 
+			return new BSTNode(data);
+		}
+		if(data<root.data){
+			insertHelper(root.left, data);
+			root.lcount++;
+		}else{
+			insertHelper(root.right, data);
+			root.rcount++;
+		}
+		return root;
+	}
+}

Trees/BST/BSTNode.java

@@ -0,0 +1,14 @@
+package Trees.BST;
+
+public class BSTNode {
+	public int data;
+	public BSTNode left;
+	public BSTNode right;
+	public int lcount;// no of nodes on the right
+	public int rcount;// no of nodes on the left
+	public BSTNode(int data){
+		this.data = data;
+		left = right = null;
+		lcount = rcount = 0;
+	}
+}

Trees/BSTFromLevelOrder.java

@@ -0,0 +1,18 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BSTFromLevelOrder {
+	public static void main(String[] args) {
+		int[] arr = {1,2,3,4,5};
+		BinaryTree tree = new BinaryTree();
+		tree.root = build(arr,0);
+		BinaryTree.display(tree.root);
+	}
+	static TreeNode build(int[] arr, int start){
+		if(start>arr.length-1) return null;
+		TreeNode root = new TreeNode(arr[start]);
+		root.left = build(arr, 2*start+1);
+		root.right = build(arr, 2*start+2);
+		return root;
+	}
+}

Trees/BSTFromPostOrder.java

@@ -0,0 +1,24 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BSTFromPostOrder {
+	public static void main(String[] args) {
+		int[] p = {1, 7, 5, 50, 40, 10};
+		BinaryTree tree = new BinaryTree();
+		tree.root = build(p, 0, p.length-1);
+		BinaryTree.display(tree.root);
+	}
+	static TreeNode build(int[] post, int start, int end){
+		if(start>end) return null;
+		TreeNode root = new TreeNode(post[end]);
+		if(start==end) return root;
+		int idx = start;
+		while(post[end]>post[idx]){
+			idx++;
+		}
+		int k = idx-start;
+		root.left = build(post, start, start+k-1);
+		root.right = build(post, start+k, end-1);
+		return root;
+	}
+}

Trees/BSTFromPreOrder.java

@@ -0,0 +1,22 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BSTFromPreOrder {
+	public TreeNode bstFromPreorder(int[] pre) {
+        return help(pre,0,pre.length-1);
+    }
+    static TreeNode help(int[] pre, int start, int end){
+        if(start>end) return null;
+        TreeNode root = new TreeNode(pre[start]);
+        if(start==end) return root;
+        int idx = start;
+        while(idx< pre.length && pre[start]>=pre[idx]){
+            idx++;
+        }
+        int k = idx-start;
+        root.left = help(pre,start+1,start+k-1);
+        root.right = help(pre,start+k,end);
+        return root;
+
+    }
+}

Trees/BSTtoGST.java

@@ -0,0 +1,17 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BSTtoGST {
+	int sum = 0;
+    public TreeNode bstToGst(TreeNode root){
+        if(root==null){
+            return null;
+        }
+        bstToGst(root.right);
+        root.val +=sum;
+        sum = root.val;
+        bstToGst(root.left);
+        return root;
+    }
+
+}

Trees/BTFromLevelOrderAndInOrder.java

@@ -0,0 +1,25 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BTFromLevelOrderAndInOrder {
+	public static void main(String[] args) {
+		int[] in = { 4, 2, 5, 1, 6, 3, 7 };
+		int[] lo = { 1, 2, 3, 4, 5, 6, 7 };
+		BinaryTree tree = new BinaryTree();
+		tree.root = build(in, 0, in.length-1, lo, 0, lo.length-1);
+		BinaryTree.display(tree.root);
+	}
+	static TreeNode build(int[] in, int inStart, int inEnd, int[] level, int lStart, int lEnd){
+		if(inStart>inEnd||lStart>level.length-1)return null;
+		TreeNode root = new TreeNode(level[lStart]);
+		if(inStart==inEnd) return root;
+		int idx = inStart;
+		while(level[lStart]!=in[idx]){
+			idx++;
+		}
+		int k = idx-inStart;
+		root.left = build(in, inStart, inStart+k-1, level, 2*lStart+1, lEnd);
+		root.right = build(in, inStart+k+1, inEnd, level, 2*lStart+2, lEnd);
+		return root;
+	}
+}

Trees/BTFromPostOrderAndInOrder.java

@@ -0,0 +1,26 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BTFromPostOrderAndInOrder {
+	public static void main(String[] args) {
+		int[] pre = {9,15,7,20,3};
+		int[] in = {9,3,15,20,7};
+		BinaryTree tree = new BinaryTree();
+		tree.root = build(in, pre, 0, in.length-1,0, pre.length-1);
+		BinaryTree.display(tree.root);
+	}
+	static TreeNode build(int[] in, int[] post, int inStart, int inEnd,int pStart,int pEnd){
+		if(pStart>pEnd || inStart>inEnd) return null;
+		TreeNode root = new TreeNode(post[pEnd]);
+		int i = find(in, inStart, inEnd, post[pEnd]);
+		root.left = build(in, post, inStart, i-1, pStart,pStart+i-inStart-1);
+		root.right = build(in, post, i+1, inEnd, pStart+i -inStart,pEnd-1);
+		return root;
+	}
+	static int find(int[] in, int inStart, int inEnd,int ele){
+		for(int i=inStart;i<=inEnd;i++){
+			if(in[i]==ele) return i;
+		}
+		return -1;
+	}
+}

Trees/BTFromPreOrderAndInOrder.java

@@ -0,0 +1,28 @@
+package Trees;
+
+import Trees.BinaryTree.BinaryTree;
+import Trees.BinaryTree.TreeNode;
+
+public class BTFromPreOrderAndInOrder {
+	public static void main(String[] args) {
+		int[] pre = {3,9,20,15,7};
+		int[] in = {9,3,15,20,7};
+		BinaryTree tree = new BinaryTree();
+		tree.root = build(in, pre, 0, in.length-1, 0,pre.length-1);
+		BinaryTree.display(tree.root);
+	}
+	static TreeNode build(int[] in, int[] pre, int inStart, int inEnd ,int pStart,int pEnd){
+		if(inStart>inEnd) return null;
+		TreeNode root = new TreeNode(pre[pStart]);
+		int i = find(in, inStart, inEnd,pre[pStart]);
+		root.left = build(in, pre, inStart, i-1, pStart+1,pEnd+(i-inStart));
+		root.right = build(in, pre, i+1, inEnd, pStart+(i-inStart)+1,pEnd);
+		return root;
+	}
+	static int find(int[] in, int inStart, int inEnd,int ele){
+		for(int i=inStart;i<=inEnd;i++){
+			if(in[i]==ele) return i;
+		}
+		return -1;
+	}
+}

Trees/BTFromPreOrderAndPostOrder.java

@@ -0,0 +1,22 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BTFromPreOrderAndPostOrder {
+	public TreeNode constructFromPrePost(int[] pre, int[] post) {
+        return help(pre,post,0,pre.length-1,0,post.length-1);
+    }
+    public TreeNode help(int[] pre, int[] post, int s1, int e1, int s2, int e2){
+       if(s1>e1) return null;
+        TreeNode root = new TreeNode(pre[s1]);
+        if(s1==e1) return root;
+        int idx = s2;
+        while(post[idx]!=pre[s1+1]){
+            idx++;
+        }
+        int k = idx-s2+1;
+        root.left = help(pre,post,s1+1,s1+k,s2,idx);
+        root.right = help(pre,post,s1+k+1,e1,idx+1,e2-1);
+        return root;
+
+    }
+}

Trees/BinaryTree/BinaryTree.java

@@ -0,0 +1,30 @@
+package Trees.BinaryTree;
+
+
+public class BinaryTree {
+	public TreeNode root;
+	public TreeNode create(int[] arr){
+		if(arr.length==0) return null;
+		root = new TreeNode(arr[0]);
+		return insert(arr, root, 0);
+	}
+	private TreeNode insert(int[] arr,TreeNode root, int i){
+		// level-wise
+		if(i<arr.length){
+			TreeNode node = new TreeNode(arr[i]);
+			root = node;
+			node.left = insert(arr, root.left, 2*i+1);
+			node.right = insert(arr, root.right, 2*i+2);
+		}
+		return root;
+	}
+	public static void display(TreeNode node){
+		if(node==null) return;
+		String str = node.val+"";
+		str+= node.left==null?"":" L: "+node.left.val;
+		str+= node.right==null?"":" R: "+node.right.val;
+		System.out.println(str);
+		display(node.left);
+		display(node.right);
+	}
+}

Trees/BinaryTree/TreeNode.java

@@ -0,0 +1,11 @@
+package Trees.BinaryTree;
+
+public class TreeNode {
+	public int val;
+	public TreeNode left;
+	public TreeNode right;
+	public TreeNode(int val){
+		this.val = val;
+		right = left = null;
+	}
+}

Trees/BinaryTreeToCircularDLL.java

@@ -0,0 +1,47 @@
+package Trees;
+
+import Trees.BinaryTree.*;
+public class BinaryTreeToCircularDLL {
+	public static void main(String[] args) {
+		BinaryTree tree = new BinaryTree();
+		tree.root = new TreeNode(10);
+		tree.root.left = new TreeNode(12);
+		tree.root.left.left = new TreeNode(25);
+		tree.root.left.right = new TreeNode(30);
+		tree.root.right = new TreeNode(15);
+		tree.root.right.left = new TreeNode(36);
+		tree.root = convertToDLL(tree.root);
+		display(tree.root);
+
+	}
+	static void display(TreeNode root){
+		TreeNode temp = root;
+		System.out.print(temp.val+" ");
+		temp = temp.right;
+		while(temp!=root){
+			System.out.print(temp.val+" ");
+			temp = temp.right;
+		}
+	}
+	static TreeNode head = null;
+	static TreeNode prev = null;
+	static TreeNode convertToDLL(TreeNode root){
+		convert(root);
+		head.left = prev;
+		prev.right = head;
+		return head;
+	}
+	static void convert(TreeNode node){
+		if(node==null) return;
+		convert(node.left);
+		if(prev==null){
+			head = node;
+		}else{
+			prev.right = node;
+			node.left = prev;
+		}
+		prev = node;
+		convert(node.right);
+	}
+
+}