Day - 74 work

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 107 |
-| Current Streak | 73 days |
-| Longest Streak | 73 ( August 17, 2015 - October 28, 2015 ) |
+| Total Problems | 109 |
+| Current Streak | 74 days |
+| Longest Streak | 74 ( August 17, 2015 - October 29, 2015 ) |
 
 </center>
 
@@ -114,6 +114,8 @@ Include contains single header implementation of data structures and some algori
 |Convert a tree to sumTree, such that each node is sum of left and right subtree of the original tree.| [convert_to_sum_tree.cpp](tree_problems/convert_to_sum_tree.cpp)|
 | Convert a sorted array to balanced binary search tree.| [sortedArrayToBST.cpp](tree_problems/sortedArrayToBST.cpp)|
 | Given a binary tree, generate sum of each vertical column.|[verticalSum.cpp](tree_problems/verticalSum.cpp)|
+| Given a binary tree and key, node with key exists in tree. Find all the ancestors of the node with key, ancestor here are the nodes which are in straight path from node to root.| [node_ancestors_in_root_path.cpp](tree_problems/node_ancestors_in_root_path.cpp)|
+| Given a binary tree and key, return the level of the node with key. Root is at level 1, and if node with key does not exists in tree, return 0| [level_of_node.cpp](tree_problems/level_of_node.cpp)|
 
 
 ### String Problems

tree_problems/level_of_node.cpp

@@ -0,0 +1,56 @@
+/**
+ * Given a Binary Tree and a key, write a function that returns level of the key.
+ * 				3
+ * 			/		\
+ * 			2		5
+ * 		/		\
+ * 		1		4
+ *
+ * 	Here 3 is on level 1
+ * 	2 and 5 have level 2
+ * 	1 and 4 have level 3
+ * 	If key not in tree, return 0
+ *
+ */
+#include <iostream>
+struct Node {
+	int data;
+	Node * left;
+	Node * right;
+	Node( int d ) : data{ d }, left{ nullptr }, right{ nullptr } { }
+};
+
+int get_node_level_util( Node * root, int key, int level ) {
+	if ( root == nullptr ) {
+		return 0;
+	}
+	if ( root->data == key ) {
+		return level;
+	}
+	int downlevel = get_node_level_util( root->left, key, level + 1);
+	if ( downlevel != 0 ) {
+		return downlevel;
+	}
+	downlevel = get_node_level_util( root->right, key, level + 1);
+	return downlevel;
+}
+
+int get_node_level( Node * root, int key ) {
+	return get_node_level_util( root, key, 1 );
+}
+
+void printLevels(Node * root) {
+	for ( int i = 1; i <= 6; ++i ) {
+		std::cout << "Level of node with key as " << i << " is " << get_node_level( root, i ) << std::endl;
+	}
+}
+
+int main() {
+	Node * root = new Node(3);
+	root->left = new Node(2);
+	root->right = new Node(5);
+	root->left->left = new Node(1);
+	root->left->right = new Node(4);
+	printLevels(root);
+	return 0;
+}

tree_problems/node_ancestors_in_root_path.cpp

@@ -0,0 +1,71 @@
+/**
+ * Given a binary Tree
+ *             1
+ *           /   \
+ *         2      3
+ *       /  \
+ *     4     5
+ *      \
+ *       6
+ *
+ *   Ancestor of node 6 in root path would be 4, 2, and 1.
+ *
+ */
+
+#include <iostream>
+#include <vector>
+
+struct Node {
+	int data;
+	Node * left;
+	Node * right;
+	Node( int d ) : data{ d }, left{ nullptr }, right{ nullptr } { }
+};
+
+
+bool get_ancestors_util( Node * root, int key, std::vector<int> & ancestors ) {
+	if ( root == nullptr ) {
+		return false;
+	}
+
+	if ( root->data == key ) {
+		return true;
+	}
+
+	if ( get_ancestors_util(root->left, key, ancestors) ||
+		 get_ancestors_util(root->right, key, ancestors) ) {
+		ancestors.push_back(root->data);
+		return true;
+	}
+	return false;
+}
+
+std::vector<int> get_ancestors( Node * root, int key ) {
+	std::vector<int> ancestors;
+	get_ancestors_util(root, key, ancestors);
+	return ancestors;
+}
+
+void printAncestors( Node * root ) {
+	std::vector<int> vec;
+	for ( int i = 1; i <= 6; ++i ) {
+		std::cout << "Ancestor of node with key " << i << " are:";
+		vec = get_ancestors( root, i );
+		for ( auto v : vec ) {
+			std::cout << v << " ";
+		}
+		std::cout << std::endl;
+		vec.clear();
+	}
+}
+
+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);
+	root->left->left->right = new Node(6);
+	printAncestors(root);
+	return 0;
+}