Day - 73 work

Author: mandliya

README.md

@@ -6,9 +6,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 105 |
-| Current Streak | 72 days |
-| Longest Streak | 72 ( August 17, 2015 - October 27, 2015 ) |
+| Total Problems | 107 |
+| Current Streak | 73 days |
+| Longest Streak | 73 ( August 17, 2015 - October 28, 2015 ) |
 
 </center>
 
@@ -112,6 +112,8 @@ Include contains single header implementation of data structures and some algori
 |Given a binary tree, print out all of its root-to-leaf paths one per line.| [printAllRootToLeafPath.cpp](tree_problems/printAllRootToLeafPath.cpp)
 |Determine if a tree is sum tree. A SumTree is a Binary Tree where the value of a node is equal to sum of the nodes present in its left subtree and right subtree. An empty tree is SumTree and sum of an empty tree can be considered as 0. A leaf node is also considered as SumTree.| [sumTree.cpp](tree_problems/sumTree.cpp)|
 |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)|
 
 
 ### String Problems

tree_problems/sortedArrayToBST.cpp

@@ -0,0 +1,50 @@
+/**
+ * Given a sorted array, convert it balaned binary search tree.
+ */
+
+#include<iostream>
+#include<vector>
+
+struct Node {
+	int data;
+	Node * left;
+	Node * right;
+	Node( int d ) : data{ d }, left{ nullptr }, right{ nullptr } { }
+};
+
+Node * sortedArrayToBST( std::vector<int> & arr, int start, int end ) {
+	if ( start > end ) {
+		return nullptr;
+	}
+	int mid = ( start + end )/2;
+	Node * node = new Node(arr[mid]);
+	node->left = sortedArrayToBST( arr, start, mid - 1 );
+	node->right = sortedArrayToBST( arr, mid + 1, end );
+	return node;
+}
+
+void printArray( std::vector<int> & arr ) {
+	for ( auto i : arr ) {
+		std::cout << i << " ";
+	}
+	std::cout << std::endl;
+}
+
+void printTreeInOrder( Node * root ) {
+	if( root ) {
+		printTreeInOrder( root->left );
+		std::cout << root->data << " ";
+		printTreeInOrder( root->right );
+	}
+}
+
+int main() {
+	std::vector<int> arr{ 1, 2, 3, 4, 5, 6, 7, 8 };
+	std::cout << "Arr  :";
+	printArray(arr);
+	Node * root = sortedArrayToBST(arr, 0, arr.size() - 1);
+	std::cout << "Tree :";
+	printTreeInOrder(root);
+	std::cout << std::endl;
+	return 0;
+}

tree_problems/verticalSum.cpp

@@ -0,0 +1,75 @@
+/**
+ * Given a binary Tree
+ * 			1
+ * 		/		\
+ * 	   2		 3
+ * 	 /	\		/ \
+ *  4	5 	   6   7
+ *
+ *  Find vertical sums of the tree.
+ *  Align the nodes in vertical line.
+ *  Here
+ *  The tree has 5 vertical lines
+ *
+ *  Vertical-Line-1 has only one node 4 => vertical sum is 4
+ *  Vertical-Line-2: has only one node 2=> vertical sum is 2
+ *  Vertical-Line-3: has three nodes: 1,5,6 => vertical sum is 1+5+6 = 12
+ *  Vertical-Line-4: has only one node 3 => vertical sum is 3
+ *  Vertical-Line-5: has only one node 7 => vertical sum is 7
+ *
+ *  So expected output is 4, 2, 12, 3 and 7
+ *
+ */
+
+#include <iostream>
+#include <unordered_map>
+#include <vector>
+#include <algorithm>
+#include <map>
+
+struct Node {
+	int data;
+	Node * left;
+	Node * right;
+	Node ( int d ) : data{ d }, left{ nullptr }, right{ nullptr } { }
+};
+
+void vertical_sum_util( Node * root, int dist, std::unordered_map<int,int> & vmap) {
+	if ( root == nullptr )  {
+		return ;
+	}
+	if ( vmap.find(dist) != vmap.end() )  {
+		vmap[dist] += root->data;
+	} else {
+		vmap[dist] = root->data;
+	}
+	vertical_sum_util( root->left, dist-1, vmap);
+	vertical_sum_util( root->right, dist+1, vmap);
+}
+
+void vertical_sum( Node * root ) {
+	if ( root == nullptr )  {
+		return;
+	}
+	std::unordered_map<int, int> vmap;
+	vertical_sum_util( root, 0, vmap );
+	std::map<int, int> ordered( vmap.begin(), vmap.end());
+	std::cout << "Printing vertical sum values, first column represent the position of vertical column with respect to root(0)\n"
+			  << "and second column represent vertical sum for that column\n";
+	for ( auto it = ordered.begin(); it != ordered.end(); ++it ) {
+		std::cout << it->first << "	" << it->second << std::endl;
+	}
+}
+
+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->right->left = new Node(6);
+	root->right->right = new Node(7);
+	vertical_sum(root);
+	return 0;
+
+}