Day 40 convert to sumTree

Author: mandliya

README.md

@@ -4,9 +4,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 58 |
-| Current Streak | 39 |
-| Longest Streak | 39 ( August 17, 2015 - September 24, 2015 ) |
+| Total Problems | 59 |
+| Current Streak | 40 |
+| Longest Streak | 40 ( August 17, 2015 - September 25, 2015 ) |
 
 </center>
 
@@ -85,6 +85,7 @@ Include contains single header implementation of data structures and some algori
 |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)
 |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)|
 
 
 ### String Problems

tree_problems/convert_to_sum_tree.cpp

@@ -0,0 +1,71 @@
+/**
+ * Convert a given tree to to sum tree.
+ * Given : A tree with positive and negative data values.
+ * Convert this to a tree where each node contains the sum of the left and right sub trees in the original tree.
+ * The values of leaf nodes are changed to 0.
+ *         		10                             20
+ *         /      \                       /       \
+ *       -2        6          ---->     4         12
+ *      /   \      /  \               /   \      /  \
+ *    8     -4    7    5             0    0     0    0
+ */
+
+#include <iostream>
+
+struct Node {
+  int data;
+  Node * left;
+  Node * right;
+  Node( int d )
+  : data{ d },
+    left{ nullptr },
+    right{ nullptr } { }
+};
+
+int  toSumTree( Node * root )
+{
+  if ( root == nullptr )
+  {
+    return 0;
+  }
+
+  //store the previous value
+  int previous_val = root->data;
+
+  // make current node as sum of left and right node. left nodes will become zero
+  root->data =  toSumTree(root->left) +  toSumTree(root->right);
+
+  // Now since each node contains the sum of the left and right sub trees in the original tree.
+  // we will return the sum of old + new value as sum.
+  // Focus on the world original here, and try understanding it from top to bottom.
+  return root->data + previous_val;
+}
+
+void inorder( Node * root )
+{
+  if ( root ) {
+    inorder(root->left);
+    std::cout << root->data << " ";
+    inorder(root->right);
+  }
+}
+
+
+int main()
+{
+  Node * root = new Node(10);
+  root->left = new Node(-2);
+  root->right = new Node(6);
+  root->left->left = new Node(8);
+  root->left->right = new Node(-4);
+  root->right->left = new Node(7);
+  root->right->right = new Node(5);
+  std::cout << "Inorder traversal of tree:";
+  inorder(root);
+  std::cout << "\nAfter transforming to sum tree\n";
+   toSumTree(root);
+  std::cout << "Inorder traversal of tree:";
+  inorder(root);
+  std::cout << std::endl;
+  return 0;
+}