add python solution to some questions

Author: Kurt-Yu

README.md

@@ -8,14 +8,19 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|951|[Flip Equivalent Binary Trees](https://leetcode.com/problems/flip-equivalent-binary-trees/) | [Python](./algorithms/python/FlipEquivalentBinaryTrees/flipEquiv.py)|Medium|
 |859|[Buddy Strings](https://leetcode.com/problems/buddy-strings/description/) | [C++](./algorithms/cpp/buddyStrings/BuddyStrings.cpp)|Easy|
 |858|[Mirror Reflection](https://leetcode.com/problems/mirror-reflection/description/) | [C++](./algorithms/cpp/mirrorReflection/MirrorReflection.cpp)|Medium|
 |852|[Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/description/) | [C++](./algorithms/cpp/peakIndexInAMountainArray/PeakIndexInAMountainArray.cpp)|Easy|
 844|[Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/description/) | [C++](./algorithms/cpp/backspaceStringCompare/BackspaceStringCompare.cpp)|Easy|
 |837|[Most Common Word](https://leetcode.com/problems/most-common-word/) | [C++](./algorithms/cpp/mostCommonWord/MostCommonWord.cpp)|Easy|
 |804|[Unique Morse Code Words](https://leetcode.com/problems/unique-morse-code-words/description/) | [C++](./algorithms/cpp/uniqueMorseCodeWords/UniqueMorseCodeWords.cpp)|Easy|
 |771|[Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/description) | [C++](./algorithms/cpp/jewelsAndStones/JewelsAndStones.cpp)|Easy|
+|684|[Redundant Connection](https://leetcode.com/problems/redundant-connection/) | [Python](./algorithms/python/RedundantConnection/findRedundantConnection.py)|Medium|
+|671|[Second Minimum Node In a Binary Tree](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/) | [Python](./algorithms/python/SecondMinimumNodeInABinaryTree/findSecondMinimumValue.py)|Easy|
+|655|[Print Binary Tree](https://leetcode.com/problems/print-binary-tree/) | [Python](./algorithms/python/PrintBinaryTree/printTree.py)|Medium|
 |643|[Maximum Average Subarray I](https://leetcode.com/problems/maximum-average-subarray-i/description/) | [C++](./algorithms/cpp/maximumAverageSubarray/MaximumAverageSubarray.I.cpp)|Easy|
+|538|[Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/) | [Python](./algorithms/python/ConvertBSTtoGreaterTree/convertBST.py)|Easy|
 |477|[Total Hamming Distance](https://leetcode.com/problems/total-hamming-distance/) | [C++](./algorithms/cpp/totalHammingDistance/totalHammingDistance.cpp)|Medium|
 |418|[SentenceScreenFitting](https://leetcode.com/problems/sentence-screen-fitting/) ♥ | [C++](./algorithms/cpp/sentenceScreenFitting/sentenceScreenFitting.cpp)|Easy|
 |416|[Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum/description/) | [C++](./algorithms/cpp/partitionEqualSubsetSum/PartitionEqualSubsetSum.cpp)|Medium|
@@ -27,7 +32,7 @@ LeetCode
 |409|[Longest Palindrome](https://leetcode.com/problems/longest-palindrome/) | [C++](./algorithms/cpp/longestPalindrome/LongestPalindrome.cpp)|Easy|
 |406|[Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height/) | [C++](./algorithms/cpp/queueReconstructionByHeight/QueueReconstructionByHeight.cpp)|Medium|
 |405|[Convert a Number to Hexadecimal](https://leetcode.com/problems/convert-a-number-to-hexadecimal/) | [C++](./algorithms/cpp/convertANumberToHexadecimal/ConvertANumberToHexadecimal.cpp)|Easy|
-|404|[Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | [C++](./algorithms/cpp/sumOfLeftLeaves/SumOfLeftLeaves.cpp)|Easy|
+|404|[Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | [C++](./algorithms/cpp/sumOfLeftLeaves/SumOfLeftLeaves.cpp), [Python] (./algorithms/python/SumOfLeftLeaves/sumOfLeftLeaves.py)|Easy|
 |403|[Frog Jump](https://leetcode.com/problems/frog-jump/) | [C++](./algorithms/cpp/frogJump/FrogJump.cpp)|Hard|
 |402|[Remove K Digits](https://leetcode.com/problems/remove-k-digits/) | [C++](./algorithms/cpp/removeKDigits/RemoveKDigits.cpp)|Medium|
 |401|[Binary Watch](https://leetcode.com/problems/binary-watch/) | [C++](./algorithms/cpp/binaryWatch/BinaryWatch.cpp)|Easy|
@@ -119,12 +124,12 @@ LeetCode
 |238|[Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/)| [C++](./algorithms/cpp/productOfArrayExceptSelf/ProductOfArrayExceptSelf.cpp)|Medium|
 |237|[Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/)| [C++](./algorithms/cpp/deleteNodeInALinkedList/DeleteNodeInALinkedList.cpp)|Easy|
 |236|[Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)| [C++](./algorithms/cpp/lowestCommonAncestorOfABinaryTree/LowestCommonAncestorOfABinaryTree.cpp), [Java](./algorithms/java/src/lowestCommonAncestorOfABinaryTree/lowestCommonAncestorOfABinaryTree.java)|Medium|
-|235|[Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)| [C++](./algorithms/cpp/lowestCommonAncestorOfABinarySearchTree/LowestCommonAncestorOfABinarySearchTree.cpp)|Easy|
+|235|[Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)| [C++](./algorithms/cpp/lowestCommonAncestorOfABinarySearchTree/LowestCommonAncestorOfABinarySearchTree.cpp), [Python](./algorithms/python/LowestCommonAncestorOfABinarySearchTree/lowestCommonAncestor.py)|Easy|
 |234|[Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/)| [C++](./algorithms/cpp/palindromeLinkedList/PalindromeLinkedList.cpp)|Easy|
 |233|[Number of Digit One](https://leetcode.com/problems/number-of-digit-one/)| [C++](./algorithms/cpp/numberOfDigitOne/NumberOfDigitOne.cpp)|Medium|
 |232|[Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/)| [C++](./algorithms/cpp/implementQueueUsingStacks/ImplementQueueUsingStacks.cpp), [Java](./algorithms/java/src/myQueue/MyQueue.java)|Easy|
 |231|[Power of Two](https://leetcode.com/problems/power-of-two/)| [C++](./algorithms/cpp/powerOfTwo/PowerOfTwo.cpp)|Easy|
-|230|[Kth Smallest Element in a BST](https://leetcode.com/problems/kth-smallest-element-in-a-bst/)| [C++](./algorithms/cpp/kthSmallestElementInaBST/KthSmallestElementInABst.cpp)|Medium|
+|230|[Kth Smallest Element in a BST](https://leetcode.com/problems/kth-smallest-element-in-a-bst/)| [C++](./algorithms/cpp/kthSmallestElementInaBST/KthSmallestElementInABst.cpp), [Python] (./algorithms/python/KthSmallestElementInABST/kthSmallest.py)|Medium|
 |229|[Majority Element II](https://oj.leetcode.com/problems/majority-element-ii/) | [C++](./algorithms/cpp/majorityElement/majorityElement.II.cpp)|Medium|
 |228|[Summary Ranges](https://leetcode.com/problems/summary-ranges/)| [C++](./algorithms/cpp/summaryRanges/SummaryRanges.cpp)|Easy|
 |227|[Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii/)| [C++](./algorithms/cpp/basicCalculator/BasicCalculator.II.cpp)|Medium|

algorithms/python/ConvertBSTtoGreaterTree/convertBST.py

@@ -0,0 +1,18 @@
+"""
+since this is a BST, we can do a inorder traversal (inversed, from right to left),
+during this process, track the sum and update the node.val
+"""
+
+class Solution:
+    def convertBST(self, root):
+        self.total = 0
+        
+        def helper(node):
+            if not node: return
+            helper(node.right)
+            node.val += self.total
+            self.total = node.val
+            helper(node.left)
+        
+        helper(root)
+        return root

algorithms/python/FlipEquivalentBinaryTrees/flipEquiv.py

@@ -0,0 +1,45 @@
+"""
+Method 1: 
+    naive recursive solution, divide the original problem into four subproblems,
+    time complexity and space complexity are both O(n^2)
+"""
+def flipEquiv1(self, root1, root2):
+    if not root1 or not root2:
+        return root1 == root2
+    if root1.val != root2.val:
+        return False
+    return self.flipEquiv(root1.left, root2.left) and \
+            self.flipEquiv(root1.right, root2.right) or \
+            self.flipEquiv(root1.left, root2.right) and \
+            self.flipEquiv(root1.right, root2.left)
+
+"""
+Method 2: 
+    Step 1: first preprocessing these two trees, sort them in the following order:
+    if node.left.val > node.right.val, then swap them, make the smaller one to be left node
+    if the left node is None, then also swap them, make the non-None node to be left node
+
+    Step 2: compare the swapped trees
+
+    After preprocessing, the original problem is divided into two subproblems, time complexity: O(n)
+"""
+def flipEquiv2(self, root1, root2):
+    def flip(root):
+        if root:
+            if root.left and root.right and root.left.val > root.right.val:
+                root.left, root.right = root.right, root.left
+            if not root.left:
+                root.left, root.right = root.right, root.left
+            flip(root.left)
+            flip(root.right)
+    
+    def is_equal(root1, root2):
+        if not root1 or not root2:
+            return root1 == root2
+        return root1.val == root2.val and \
+                is_equal(root1.left, root2.left) and \
+                is_equal(root1.right, root2.right)
+    
+    flip(root1)
+    flip(root2)
+    return is_equal(root1, root2)

algorithms/python/KthSmallestElementInABST/kthSmallest.py

@@ -0,0 +1,23 @@
+# Method 1: recursive in-order traversal
+def kthSmallest1(self, root, k):
+    inorder = []
+    def helper(root):
+        if root:
+            helper(root.left)
+            inorder.append(root.val)
+            helper(root.right)
+    
+    helper(root)
+    return inorder[k-1]
+
+# Method 2: iterative in-order traversal
+def kthSmallest2(self, root, k):
+    stack = []
+    while root or stack:
+        while root:
+            stack.append(root)
+            root = root.left
+        root = stack.pop()
+        k -= 1
+        if k == 0: return root.val
+        root = root.right

algorithms/python/LowestCommonAncestorOfABinarySearchTree/lowestCommonAncestor.py

@@ -0,0 +1,9 @@
+# straight forward recursive solution
+
+def lowestCommonAncestor(self, root, p, q):
+    if not root: return None
+    if root.val > p.val and root.val > q.val:
+        return self.lowestCommonAncestor(root.left, p, q)
+    elif root.val < p.val and root.val < q.val:
+        return self.lowestCommonAncestor(root.right, p, q)
+    return root

algorithms/python/PrintBinaryTree/printTree.py

@@ -0,0 +1,20 @@
+# recursive solution: takes O(n) time
+# first get the height of the tree, then recusivly update the value
+
+def printTree(self, root):
+    def get_height(root):
+        if not root: return 0
+        return 1 + max(get_height(root.left), get_height(root.right))
+    
+    def update(res, node, row, left, right):
+        if not node: return
+        mid = (left + right) // 2
+        res[row][mid] = str(node.val)
+        update(res, node.left, row + 1, left, mid - 1)
+        update(res, node.right, row + 1, mid + 1, right)
+    
+    height = get_height(root)
+    width = 2 ** height - 1
+    res = [['' for _ in range(width)] for _ in range(height)]
+    update(res, root, 0, 0, width - 1)
+    return res

algorithms/python/RedundantConnection/findRedundantConnection.py

@@ -0,0 +1,28 @@
+"""
+simple union find with path compression:
+at first, each vertices are disjoint, there are N connected components at the begining,
+after add each edge, we unify those two connected components, if two vertices are already 
+in the same connected component, then this edge will form a circle, just return this edge
+"""
+
+def findRedundantConnection(self, edges):
+    id = list(range(len(edges) + 1))
+    
+    def find(u):
+        root = u
+        while root != id[root]: root = id[root]
+        
+        # path compression:
+        while u != root:
+            next = id[u]
+            id[u] = root
+            u = next
+        
+        return root
+    
+    for u, v in edges:
+        root1, root2 = find(u), find(v)
+        if root1 == root2: return [u, v]
+        
+        # else, unify these two components:
+        id[root1] = root2

algorithms/python/SecondMinimumNodeInABinaryTree/findSecondMinimumValue.py

@@ -0,0 +1,15 @@
+"""
+because of the special porperty of the tree, the question basically is asking to find
+the smallest element in the subtree of root. So, we can recursively find left and right
+value that is not equal to the root's value, and then return the smaller one of them
+"""
+def findSecondMinimumValue(self, root):
+    if not root: return -1
+    if not root.left and not root.right: return -1
+    
+    left, right = root.left.val, root.right.val
+    if left == root.val: left = self.findSecondMinimumValue(root.left)
+    if right == root.val: right = self.findSecondMinimumValue(root.right)
+    if left != -1 and right != -1: return min(left, right)
+    if left == -1: return right
+    if right == -1: return left

algorithms/python/SumOfLeftLeaves/sumOfLeftLeaves.py

@@ -0,0 +1,10 @@
+"""
+straight forward recursive solution:
+if left node is leave, add the value and the the right subtree
+if not, then recursively call left and right subtree
+"""
+def sumOfLeftLeaves(self, root):
+    if not root: return 0
+    if root.left and not root.left.left and not root.left.right:
+        return root.left.val + self.sumOfLeftLeaves(root.right)
+    return self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right)