From 3ab4345d8afd2af3f8b2f2dfa8cb86be1c41cf7a Mon Sep 17 00:00:00 2001 From: tadipatrisudheerreddy Date: Mon, 1 Oct 2018 21:45:14 -0700 Subject: [PATCH 1/2] Add Binary Tree traversals and regular problems --- .../algos/practice/BinaryTree.java | 52 ++++++++++++++++ .../algos/practice/LowestCommonAncestor.java | 45 ++++++++++++++ .../BinaryTrees/algos/practice/SubTree.java | 60 +++++++++++++++++++ .../BinaryTrees/algos/practice/TreeNode.java | 35 +++++++++++ .../algos/practice/TreeTraversal.java | 28 +++++++++ .../algos/practice/TreeWithNoSiblings.java | 33 ++++++++++ 6 files changed, 253 insertions(+) create mode 100644 BinaryTrees-traversals/BinaryTrees/algos/practice/BinaryTree.java create mode 100644 BinaryTrees-traversals/BinaryTrees/algos/practice/LowestCommonAncestor.java create mode 100644 BinaryTrees-traversals/BinaryTrees/algos/practice/SubTree.java create mode 100644 BinaryTrees-traversals/BinaryTrees/algos/practice/TreeNode.java create mode 100644 BinaryTrees-traversals/BinaryTrees/algos/practice/TreeTraversal.java create mode 100644 BinaryTrees-traversals/BinaryTrees/algos/practice/TreeWithNoSiblings.java diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/BinaryTree.java b/BinaryTrees-traversals/BinaryTrees/algos/practice/BinaryTree.java new file mode 100644 index 0000000..2b87783 --- /dev/null +++ b/BinaryTrees-traversals/BinaryTrees/algos/practice/BinaryTree.java @@ -0,0 +1,52 @@ +package algos.practice; + +public class BinaryTree { + + public static TreeNode mirrorTree(TreeNode node){ + if(node == null) + return node; + + TreeNode left = mirrorTree(node.left); + TreeNode right = mirrorTree(node.right); + node.left = right; + node.right = left; + + return node; + } + + public static void main(String[] args){ + + TreeNode root = new TreeNode(8); + TreeNode.insert(root, new TreeNode(31)); + TreeNode.insert(root, new TreeNode(45)); + TreeNode.insert(root, new TreeNode(16)); + TreeNode.insert(root, new TreeNode(24)); + TreeNode.insert(root, new TreeNode(19)); + TreeNode.insert(root, new TreeNode(29)); + TreeNode.insert(root, new TreeNode(7)); + + StringBuffer inorderbuf=new StringBuffer(); + StringBuffer preorderbuf=new StringBuffer(); + StringBuffer postorderbuf=new StringBuffer(); + + + TreeTraversal.getInorder(root,inorderbuf); + TreeTraversal.getPreorder(root, preorderbuf); + TreeTraversal.getPostorder(root, postorderbuf); + + System.out.println("Before mirroring,In order tree is: "+inorderbuf); + + BinaryTree.mirrorTree(root); + + StringBuffer inorderbufAfter = new StringBuffer(); + TreeTraversal.getInorder(root, inorderbufAfter); + System.out.println("After mirroring,In order tree is: "+inorderbufAfter); + + System.out.println("Post order traversal:" + postorderbuf); + System.out.println("Pre order traversal:"+ preorderbuf); + + System.out.println("Nodes with no siblings:"); + TreeWithNoSiblings.printOnlyLeaves(root); + + } +} diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/LowestCommonAncestor.java b/BinaryTrees-traversals/BinaryTrees/algos/practice/LowestCommonAncestor.java new file mode 100644 index 0000000..0407106 --- /dev/null +++ b/BinaryTrees-traversals/BinaryTrees/algos/practice/LowestCommonAncestor.java @@ -0,0 +1,45 @@ +package algos.practice; + +public class LowestCommonAncestor { + + TreeNode root; + + public TreeNode LCA(int p,int q){ + return findLCA(root,p,q); + } + + private TreeNode findLCA(TreeNode root, int p, int q) { + if(root == null) + return null; + if(root.value == p || root.value == q) + return root; + + TreeNode left = findLCA(root.left,p,q); + TreeNode right = findLCA(root.right,p,q); + + if(left!=null && right!=null) + return root; + + return left!=null? left : right; + } + + + + public static void main(String[] args){ + + LowestCommonAncestor lca = new LowestCommonAncestor(); + + TreeNode root = new TreeNode(1); + root.left = new TreeNode(2); + root.right = new TreeNode(3); + root.left.left = new TreeNode(4); + root.left.right = new TreeNode(5); + root.right.left = new TreeNode(6); + root.right.right = new TreeNode(7); + + + System.out.println("Lowest Common Ancestor of (4,5): "+ lca.findLCA(root, 4, 5).value); + System.out.println("Lowest Common Ancestor of (4,6): "+ lca.findLCA(root, 4, 6).value); + System.out.println("Lowest Common Ancestor of (3,4): "+ lca.findLCA(root, 3, 4).value); + } +} diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/SubTree.java b/BinaryTrees-traversals/BinaryTrees/algos/practice/SubTree.java new file mode 100644 index 0000000..20de5b0 --- /dev/null +++ b/BinaryTrees-traversals/BinaryTrees/algos/practice/SubTree.java @@ -0,0 +1,60 @@ +package algos.practice; + +public class SubTree { + + TreeNode root1, root2; + + public boolean isIdentical(TreeNode root1,TreeNode root2){ + + //Since every null tree is also subset of main tree + if(root1==null&&root2==null) + return true; + //Need to check the null condition only once,since we are using recursion at second time it should not be null + if(root1==null&&root2==null) + return false; + + return (root1.value==root2.value)&& (isIdentical(root1.left,root2.left)) + &&((isIdentical(root1.right,root2.right)) ); + } + + public boolean isSubTree(TreeNode p, TreeNode q){ + + //Since every null tree is also subset of main tree + if(q==null) + return true; + + if(p==null) + return false; + + if(isIdentical(p,q)) + return true; + + return isSubTree(p.left,q)||isSubTree(p.right,q); + } + + + public static void main(String[] args) { + + SubTree tree = new SubTree(); + + TreeNode root1 = new TreeNode(26); + root1.right = new TreeNode(3); + root1.right.right = new TreeNode(3); + root1.left = new TreeNode(10); + root1.left.left = new TreeNode(4); + root1.left.left.right = new TreeNode(30); + root1.left.right = new TreeNode(6); + + TreeNode root2 = new TreeNode(10); + root2.right = new TreeNode(6); + root2.left = new TreeNode(4); + root2.left.right = new TreeNode(30); + + if(tree.isSubTree(tree.root1,tree.root2)) + System.out.println("Tree2 is subtree of Tree1"); + else + System.out.println("Tree2 is not a subtree of Tree1"); + + } + +} diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeNode.java b/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeNode.java new file mode 100644 index 0000000..c6ab982 --- /dev/null +++ b/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeNode.java @@ -0,0 +1,35 @@ +package algos.practice; + +public class TreeNode { + + int value; + TreeNode left; + TreeNode right; + + public TreeNode(int i) { + value = i; + left = right = null; + } + + public static boolean insert(TreeNode root,TreeNode n){ + if(n!=null){ + if(n.value >= root.value){ + if(root.right==null){ + root.right=n; + return true; + } + else + return insert(root.right,n); + } + else if(root.left==null){ + root.left=n; + return true; + } + else + return insert(root.left,n); + } + return false; + + } + +} diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeTraversal.java b/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeTraversal.java new file mode 100644 index 0000000..5283a56 --- /dev/null +++ b/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeTraversal.java @@ -0,0 +1,28 @@ +package algos.practice; + +public class TreeTraversal { + + public static void getInorder(TreeNode node,StringBuffer buf){ + if(node == null) + return; + getInorder(node.left,buf); + buf.append(" "+node.value); + getInorder(node.right,buf); + } + + public static void getPreorder(TreeNode node,StringBuffer buf){ + if(node==null) + return; + buf.append(" "+node.value); + getPreorder(node.left,buf); + getPreorder(node.right,buf); + } + + public static void getPostorder(TreeNode node,StringBuffer buf){ + if(node==null) + return; + getPostorder(node.left,buf); + getPostorder(node.right,buf); + buf.append(" "+node.value); + } +} diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeWithNoSiblings.java b/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeWithNoSiblings.java new file mode 100644 index 0000000..13211f4 --- /dev/null +++ b/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeWithNoSiblings.java @@ -0,0 +1,33 @@ +package algos.practice; + +public class TreeWithNoSiblings { + public static void printOnlyLeaves(TreeNode node){ + if(node!=null){ + + printOnlyLeaves(node.left); + + if ((node.left==null) && (node.right!=null)) + System.out.println("Node with no sibling in right side is: " + node.right.value); + + if((node.left!=null) && (node.right==null)) + System.out.println("Node with no sibling in left side is: " + node.left.value); + + printOnlyLeaves(node.right); + } + } + + public static void main(String[] args){ + + TreeNode root = new TreeNode(50); + TreeNode.insert(root, new TreeNode(30)); + TreeNode.insert(root, new TreeNode(60)); + TreeNode.insert(root, new TreeNode(22)); + TreeNode.insert(root, new TreeNode(38)); + TreeNode.insert(root, new TreeNode(55)); + TreeNode.insert(root, new TreeNode(34)); + + + TreeWithNoSiblings.printOnlyLeaves(root); + } + +} From 20d22cbca2fe24a869fc6aeb576c68a6dca1bcc7 Mon Sep 17 00:00:00 2001 From: tadipatrisudheerreddy Date: Tue, 2 Oct 2018 18:30:39 -0700 Subject: [PATCH 2/2] Make the folder structure and code format in the files --- .../{BinaryTrees/algos/practice => }/BinaryTree.java | 8 +++++++- .../algos/practice => }/LowestCommonAncestor.java | 7 ++++++- .../{BinaryTrees/algos/practice => }/SubTree.java | 8 ++++++-- .../{BinaryTrees/algos/practice => }/TreeNode.java | 7 ++++++- .../{BinaryTrees/algos/practice => }/TreeTraversal.java | 7 ++++++- .../algos/practice => }/TreeWithNoSiblings.java | 7 ++++++- 6 files changed, 37 insertions(+), 7 deletions(-) rename BinaryTrees-traversals/{BinaryTrees/algos/practice => }/BinaryTree.java (91%) rename BinaryTrees-traversals/{BinaryTrees/algos/practice => }/LowestCommonAncestor.java (88%) rename BinaryTrees-traversals/{BinaryTrees/algos/practice => }/SubTree.java (91%) rename BinaryTrees-traversals/{BinaryTrees/algos/practice => }/TreeNode.java (80%) rename BinaryTrees-traversals/{BinaryTrees/algos/practice => }/TreeTraversal.java (82%) rename BinaryTrees-traversals/{BinaryTrees/algos/practice => }/TreeWithNoSiblings.java (85%) diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/BinaryTree.java b/BinaryTrees-traversals/BinaryTree.java similarity index 91% rename from BinaryTrees-traversals/BinaryTrees/algos/practice/BinaryTree.java rename to BinaryTrees-traversals/BinaryTree.java index 2b87783..d69b9f1 100644 --- a/BinaryTrees-traversals/BinaryTrees/algos/practice/BinaryTree.java +++ b/BinaryTrees-traversals/BinaryTree.java @@ -1,4 +1,10 @@ -package algos.practice; +/** + * Binary Tree Traversals implementation in Java + * + * @author: {Sudheer Reddy T} + * @github: {tadipatrisudheerreddy} + */ + public class BinaryTree { diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/LowestCommonAncestor.java b/BinaryTrees-traversals/LowestCommonAncestor.java similarity index 88% rename from BinaryTrees-traversals/BinaryTrees/algos/practice/LowestCommonAncestor.java rename to BinaryTrees-traversals/LowestCommonAncestor.java index 0407106..eb74e5b 100644 --- a/BinaryTrees-traversals/BinaryTrees/algos/practice/LowestCommonAncestor.java +++ b/BinaryTrees-traversals/LowestCommonAncestor.java @@ -1,4 +1,9 @@ -package algos.practice; +/** + * To find Lowest Common Ancestor for a binary tree implementation in Java + * + * @author: {Sudheer Reddy T} + * @github: {tadipatrisudheerreddy} + */ public class LowestCommonAncestor { diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/SubTree.java b/BinaryTrees-traversals/SubTree.java similarity index 91% rename from BinaryTrees-traversals/BinaryTrees/algos/practice/SubTree.java rename to BinaryTrees-traversals/SubTree.java index 20de5b0..ed8d10d 100644 --- a/BinaryTrees-traversals/BinaryTrees/algos/practice/SubTree.java +++ b/BinaryTrees-traversals/SubTree.java @@ -1,5 +1,9 @@ -package algos.practice; - +/** + * Binary Tree Identical implementation in Java + * + * @author: {Sudheer Reddy T} + * @github: {tadipatrisudheerreddy} + */ public class SubTree { TreeNode root1, root2; diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeNode.java b/BinaryTrees-traversals/TreeNode.java similarity index 80% rename from BinaryTrees-traversals/BinaryTrees/algos/practice/TreeNode.java rename to BinaryTrees-traversals/TreeNode.java index c6ab982..11ad3a0 100644 --- a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeNode.java +++ b/BinaryTrees-traversals/TreeNode.java @@ -1,4 +1,9 @@ -package algos.practice; +/** + * Binary Tree Node implementation in Java + * + * @author: {Sudheer Reddy T} + * @github: {tadipatrisudheerreddy} + */ public class TreeNode { diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeTraversal.java b/BinaryTrees-traversals/TreeTraversal.java similarity index 82% rename from BinaryTrees-traversals/BinaryTrees/algos/practice/TreeTraversal.java rename to BinaryTrees-traversals/TreeTraversal.java index 5283a56..9443295 100644 --- a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeTraversal.java +++ b/BinaryTrees-traversals/TreeTraversal.java @@ -1,4 +1,9 @@ -package algos.practice; +/** + * Binary Tree Traversals implementation in Java + * + * @author: {Sudheer Reddy T} + * @github: {tadipatrisudheerreddy} + */ public class TreeTraversal { diff --git a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeWithNoSiblings.java b/BinaryTrees-traversals/TreeWithNoSiblings.java similarity index 85% rename from BinaryTrees-traversals/BinaryTrees/algos/practice/TreeWithNoSiblings.java rename to BinaryTrees-traversals/TreeWithNoSiblings.java index 13211f4..d0dffb1 100644 --- a/BinaryTrees-traversals/BinaryTrees/algos/practice/TreeWithNoSiblings.java +++ b/BinaryTrees-traversals/TreeWithNoSiblings.java @@ -1,4 +1,9 @@ -package algos.practice; +/** + * To find the Tree with no siblings - implementation in Java + * + * @author: {Sudheer Reddy T} + * @github: {tadipatrisudheerreddy} + */ public class TreeWithNoSiblings { public static void printOnlyLeaves(TreeNode node){