Python solutions

Author: mandliya

README.md

@@ -8,6 +8,8 @@
 | :------------: | :----------: |
 | Total Problems | 188 |
 
+Current Daily Streak: 1 (started on 06/20/2019)
+
 </center>
 
 **Note: Some of the code here is old and was written when I was learning C++. It might be possible that code is not safe or making wrong assumptions. Please use with caution. Pull requests are always welcome.**
@@ -119,7 +121,7 @@ Include contains single header implementation of data structures and some algori
 |Given a binary tree (unlike binary search tree), find the Lowest Common Ancestor (LCA).|[lowest-common-ancestor-binary-tree.cpp](tree_problems/lowest-common-ancestor-binary-tree.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)|
+|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_to_sum_tree.py](tree_problems/convert_to_sum_tree.py)|
 | 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)|
@@ -131,7 +133,7 @@ Include contains single header implementation of data structures and some algori
 | Find kth smallest element in a binary search tree | [kth_smallest.cpp](tree_problems/kth_smallest.cpp)|
 | Validate if a given binary tree is a binary search tree. | [validate_bst.cpp](tree_problems/validate_bst.cpp) |
 | Given a Binary Search Tree and a target number, return true if there exist two elements in the BST such that their sum is equal to the given target.| [find_target_k.cpp](tree_problems/find_target_k.cpp) |
-| Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target. Also, to note that the target value is a floating point. There will be only one unique value which is closest to the target. |[closest_bst_value.cpp](tree_problems/closest_bst_value.cpp) |
+| Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target. Also, to note that the target value is a floating point. There will be only one unique value which is closest to the target. |[closest_bst_value.cpp](tree_problems/closest_bst_value.cpp), [closest_bst_value.py](tree_problems/closest_bst_value.py) |
 | Given a binary tree, traversing preorder, construct a string output containing node values and parenthesis. The null node needs to be represented by empty parenthesis pair "()". And you need to omit all the empty parenthesis pairs that don't affect the one-to-one mapping relationship between the string and the original binary tree. Examples in code file| [string_from_tree.cpp](tree_problems/string_from_tree.cpp)|
 
 ### String Problems

tree_problems/closest_bst_value.cpp

@@ -67,10 +67,10 @@ int main()
     std::cout << "Inorder traversal of tree: ";
     print_inorder(root);
     std::cout << std::endl;
-    std::cout << "Closest value from 8.6778 is :" << closest_bst_value(root, 3.6778)
+    std::cout << "Closest value from 3.6778 is :" << closest_bst_value(root, 3.6778)
         << std::endl;
 
-    std::cout << "(Iterative) Closest value from 8.6778 is :"
+    std::cout << "(Iterative) Closest value from 3.6778 is :"
         << closest_bst_value_iterative(root, 3.6778) << std::endl;
     return 0;
 }

tree_problems/closest_bst_value.py

@@ -0,0 +1,95 @@
+'''
+Given a non-empty binary search tree and a target value, 
+find the value in the BST that is closest to the target.
+Also, to note that the target value is a floating point.
+There will be only one unique value which is closest to the target.
+'''
+
+import sys
+
+
+class TreeNode:
+    '''
+    A tree's node representation
+    '''
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+def closest_diff_util(node, target, min_diff, min_diff_data):
+    ''' Util function to find the node closest to target
+    Params:
+    node -- node in the current BST tree
+    target -- The value to which closest node needs to be found.
+    min_diff -- minimum difference between target and the nodes we have iterated so far
+    min_diff_data -- the value of node which is closest to target so far.
+    '''
+    if node == None:
+        return
+
+    # If the target itself is present in the tree.
+    if node.data == target:
+        min_diff_data[0] = target
+        return
+
+    if min_diff > abs(node.data - target):
+        min_diff = abs(node.data - target)
+        min_diff_data[0] = node.data
+
+    if target < node.data:
+        closest_diff_util(node.left, target, min_diff, min_diff_data)
+    else:
+        closest_diff_util(node.right, target, min_diff, min_diff_data)
+
+def closest_diff(root, target):
+    '''Function to find the node closest to target
+    Params:
+        root -- the root node of the tree
+        target -- the value to which closest node needs to be found.
+    '''
+    min_diff, min_diff_data = sys.maxsize, [-1]
+    closest_diff_util(root, target, min_diff, min_diff_data)
+    return min_diff_data[0]
+
+def closest_diff_iter(root, target):
+    '''Function to find the node closest to target iteratively
+    Params:
+        root -- the root node of the tree
+        target -- the value to which closest node needs to be found.
+    '''
+    if not root:
+        return sys.maxsize
+    closest = root.data
+    while root:
+        if abs(target - closest) >= abs(target - root.data):
+            closest = root.data
+        root = root.left if target < root.data else root.right
+    return closest
+
+def inorder(root):
+    """Print inorder traversal of the tree.
+    Param:
+        root -- root of the tree.
+    """
+    if not root:
+        return
+    inorder(root.left)
+    print(root.data, end=" ")
+    inorder(root.right)
+
+if __name__ == '__main__':
+    root = TreeNode(10);
+    root.left = TreeNode(5);
+    root.right = TreeNode(15);
+    root.left.left = TreeNode(2);
+    root.left.right = TreeNode(7);
+    root.right.left = TreeNode(12);
+    root.right.right = TreeNode(16);
+
+    print("Inorder traversal of the tree:")
+    inorder(root)
+
+    print()
+    print("Closest value in the tree (recursively) to 6.6779 : ", closest_diff(root, 6.6779))
+    print("Closest value in the tree (iteratively) to 6.6779 : ", closest_diff_iter(root, 6.6779))

tree_problems/convert_to_sum_tree.py

@@ -0,0 +1,56 @@
+"""
+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
+ """
+
+class TreeNode:
+    """Representation of a binary tree node"""
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+def to_sum_tree(root):
+    """Converts a given binary tree to a sum tree
+    params:
+        root: Root of the binary tree
+    """
+    if not root:
+        return 0
+
+    previous_val = root.data
+    root.data = to_sum_tree(root.left) + to_sum_tree(root.right)
+    return root.data + previous_val
+
+def inorder(root):
+    """Prints inorder traversal of the binary tree
+    params:
+        root: Root of the binary tree
+    """
+    if not root:
+        return
+    inorder(root.left)
+    print(root.data, end=' ')
+    inorder(root.right)
+
+
+if __name__ == '__main__':
+    root = TreeNode(10)
+    root.left = TreeNode(-2)
+    root.right = TreeNode(6)
+    root.left.left = TreeNode(8)
+    root.left.right = TreeNode(-4)
+    root.right.left = TreeNode(7)
+    root.right.right = TreeNode(5)
+    print("Inorder traversal of the tree: ")
+    inorder(root)
+    to_sum_tree(root);
+    print("\nInorder traversal of the sum tree: ")
+    inorder(root)