Day-34: Tree problems

Author: mandliya

README.md

@@ -4,9 +4,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 50 |
-| Current Streak | 33 |
-| Longest Streak | 33 ( August 17, 2015 - September 18, 2015 ) |
+| Total Problems | 52 |
+| Current Streak | 34 |
+| Longest Streak | 34 ( August 17, 2015 - September 19, 2015 ) |
 
 </center>
 
@@ -78,6 +78,8 @@ Include contains single header implementation of data structures and some algori
 |Recursive Level order traveral of Tree | [levelOrderTraversalRecursive.cpp](tree_problems/levelOrderTraversalRecursive.cpp)|
 |ZigZag Traversal of Tree | [zigZagTraversal.cpp](tree_problems/zigZagTraversal.cpp)|
 |Predecessor and Successor of a given node in Binary Search Tree | [predecessorSuccessor.cpp](tree_problems/predecessorSuccessor.cpp)|
+|Given values of two nodes in a Binary Search Tree, find the Lowest Common Ancestor (LCA). Assume that both the values exist in the tree.| [lowest-common-ancestor.cpp](tree_problems/lowest-common-ancestor.cpp)|
+|Given a binary tree, print out all of its root-to-leaf paths one per line.| [printAllRootToLeafPath.cpp](tree_problems/printAllRootToLeafPath.cpp)
 
 
 ### String Problems

tree_problems/lowest-common-ancestor.cpp

@@ -0,0 +1,72 @@
+/**
+ *  Given a binary search tree, determine the lowest common ancestor of two given nodes with data
+ *  key1 and key2. Assumption is key1 and key2 exists in tree
+ *  Example
+ *  					20
+ *  			/        \
+ *  			8        22
+ *  	/      \
+ *  4        12
+ *  			/     \
+ *  		 10     14
+ *
+ * In the above tree, LCA of 10 and 14 is 12
+ * similarly 4 and 22 will have LCA 20
+ */
+
+#include <iostream>
+
+struct Node {
+  int data;
+  Node * left = nullptr;
+  Node * right = nullptr;
+  Node (int d) :
+    data{ d }, left{ nullptr }, right{ nullptr } { }
+};
+
+Node * lca ( Node * root, int key1, int key2 ) {
+  if ( root == nullptr ) {
+    return nullptr;
+  }
+  if (root->data > key1 && root->data > key2) {
+    return lca(root->left, key1, key2);
+  } else if ( root->data < key1 && root->data < key2 ) {
+    return lca(root->right, key1, key2);
+  }
+  return root;
+}
+
+
+void inorder(Node * root)
+{
+    if (root) {
+      inorder(root->left);
+      std::cout << root->data << "  ";
+      inorder(root->right);
+    }
+}
+
+int main()
+{
+  Node * root = new Node(20);
+  root->right = new Node(22);
+  root->left = new Node(8);
+  root->left->left = new Node(4);
+  root->left->right= new Node(12);
+  root->left->right->right = new Node(14);
+  root->left->right->left = new Node(10);
+  std::cout << "Inorder traversal of the tree:";
+  inorder(root);
+  std::cout << std::endl;
+
+  std::cout << std::endl;
+  std::cout << "LCA of nodes with data 10 and 14 is :"
+            << (lca(root, 14, 10))->data << std::endl;
+  std::cout << "LCA of nodes with data 14 and 8 is :"
+            << (lca(root, 14, 8))->data << std::endl;
+  std::cout << "LCA of root with data 4 and 22 is :"
+            << (lca(root, 4, 22))->data << std::endl;
+  std::cout << "LCA of root with data 14 and 10 is :"
+            << (lca(root, 10, 14))->data << std::endl;
+  return 0;
+}

tree_problems/printAllRootToLeafPath.cpp

@@ -0,0 +1,60 @@
+/**
+ *  Given a binary tree, print out all root to leaf path, one per line.
+ *  Example :
+ *  						1
+ *  				/      \
+ *  			2         3
+ *  		/ \
+ *  	4    5
+ *  	Possible paths in above tree:
+ *  	1 2 4
+ *  	1 2 5
+ *  	1 3
+ */
+
+#include <iostream>
+#include <vector>
+
+struct Node {
+  int data;
+  Node * left;
+  Node * right;
+  Node(int d) : data{ d }, left{ nullptr }, right{ nullptr } { }
+};
+
+
+void printPath( const std::vector<int> & vec )
+{
+  for (const int i : vec) {
+    std::cout << i << " ";
+  }
+  std::cout << std::endl;
+}
+
+void printPaths( Node * node, std::vector<int> paths )
+{
+    if ( node == nullptr ) {
+      return;
+    }
+    //push data to path
+    paths.push_back(node->data);
+    //leaf node
+    if ( node->left == nullptr && node->right == nullptr ) {
+      printPath(paths);
+    } else {
+      printPaths(node->left, paths);
+      printPaths(node->right, paths);
+    }
+}
+
+int main()
+{
+  Node * root = new Node(1);
+  root->left = new Node(2);
+  root->right = new Node(3);
+  root->left->left = new Node(4);
+  root->left->right = new Node(5);
+  std::vector<int> vec;
+  printPaths(root, vec);
+  return 0;
+}