added some python solutions

Author: Kurt-Yu

README.md

@@ -8,6 +8,7 @@ LeetCode
 
 | # | Title | Solution | Difficulty |
 |---| ----- | -------- | ---------- |
+|971|[Flip Binary Tree To Match Preorder Traversal](https://leetcode.com/problems/flip-binary-tree-to-match-preorder-traversal/) | [Python](./algorithms/python/FlipBinaryTreeToMatchPreorderTraversal/flipMatchVoyage.py)|Medium|
 |958|[Check Completeness of a Binary Tree](https://leetcode.com/problems/check-completeness-of-a-binary-tree/) | [Python](./algorithms/python/CheckCompletenessOfABinaryTree/isCompleteTree.py)|Medium|
 |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|
@@ -17,6 +18,7 @@ LeetCode
 |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|
+|687|[Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path/) | [Python](./algorithms/python/LongestUnivaluePath/longestUnivaluePath.py)|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|
 |662|[Maximum Width of Binary Tree](https://leetcode.com/problems/maximum-width-of-binary-tree/) | [Python](./algorithms/python/MaximumWidthOfBinaryTree/widthOfBinaryTree.py)|Medium|
@@ -31,6 +33,7 @@ LeetCode
 |477|[Total Hamming Distance](https://leetcode.com/problems/total-hamming-distance/) | [C++](./algorithms/cpp/totalHammingDistance/totalHammingDistance.cpp)|Medium|
 |450|[DeleteNodeInABST](https://leetcode.com/problems/delete-node-in-a-bst/) | [Python](./algorithms/python/DeleteNodeInABST/deleteNode.py)|Medium|
 |449|[Serialize and Deserialize BST](https://leetcode.com/problems/serialize-and-deserialize-bst/) | [Python](./algorithms/python/SerializeAndDeserializeBST/serialize.py)|Medium|
+|437|[Path Sum III](https://leetcode.com/problems/path-sum-iii/) | [Python](./algorithms/python/PathSumIII/pathSum.py)|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|
 |415|[Add Strings](https://leetcode.com/problems/add-strings/) | [C++](./algorithms/cpp/addStrings/AddStrings.cpp)|Easy|
@@ -204,8 +207,8 @@ LeetCode
 |151|[Reverse Words in a String](https://oj.leetcode.com/problems/reverse-words-in-a-string/)| [C++](./algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp), [Java](./algorithms/java/src/reverseWordsInAString/ReverseWordsInAString.java)|Medium|
 |150|[Evaluate Reverse Polish Notation](https://oj.leetcode.com/problems/evaluate-reverse-polish-notation/)| [C++](./algorithms/cpp/evaluateReversePolishNotation/evaluateReversePolishNotation.cpp)|Medium|
 |149|[Max Points on a Line](https://oj.leetcode.com/problems/max-points-on-a-line/)| [C++](./algorithms/cpp/maxPointsOnALine/maxPointsOnALine.cpp)|Hard|
-|148|[Sort List](https://oj.leetcode.com/problems/sort-list/)| [C++](./algorithms/cpp/sortList/sortList.cpp)|Medium|
-|147|[Insertion Sort List](https://oj.leetcode.com/problems/insertion-sort-list/)| [C++](./algorithms/cpp/insertionSortList/insertionSortList.cpp)|Medium|
+|148|[Sort List](https://oj.leetcode.com/problems/sort-list/)| [C++](./algorithms/cpp/sortList/sortList.cpp), [Python](./algorithms/python/SortList/sortList.py)|Medium|
+|147|[Insertion Sort List](https://oj.leetcode.com/problems/insertion-sort-list/)| [C++](./algorithms/cpp/insertionSortList/insertionSortList.cpp), [Python](./algorithms/python/InsertionSortList/insertionSortList.py)|Medium|
 |146|[LRU Cache](https://oj.leetcode.com/problems/lru-cache/)| [C++](./algorithms/cpp/LRUCache/LRUCache.cpp), [Java](./algorithms/java/src/lruCache/LRUCache.java)|Hard|
 |145|[Binary Tree Postorder Traversal](https://oj.leetcode.com/problems/binary-tree-postorder-traversal/)| [C++](./algorithms/cpp/binaryTreePostorderTraversal/binaryTreePostorderTraversal.cpp), [Python](./algorithms/python/BinaryTreePostorderTraversal/postorderTraversal.py)|Hard|
 |144|[Binary Tree Preorder Traversal](https://oj.leetcode.com/problems/binary-tree-preorder-traversal/)| [C++](./algorithms/cpp/binaryTreePreorderTraversal/binaryTreePreorderTraversal.cpp), [Java](./algorithms/java/src/binaryTreePreorderTraversal/binaryTreePreorderTraversal.java)|Medium|
@@ -254,23 +257,23 @@ LeetCode
 |101|[Symmetric Tree](https://oj.leetcode.com/problems/symmetric-tree/)| [C++](./algorithms/cpp/symmetricTree/symmetricTree.cpp)|Easy|
 |100|[Same Tree](https://oj.leetcode.com/problems/same-tree/)| [C++](./algorithms/cpp/sameTree/sameTree.cpp)|Easy|
 |99|[Recover Binary Search Tree](https://oj.leetcode.com/problems/recover-binary-search-tree/)| [C++](./algorithms/cpp/recoverBinarySearchTree/recoverBinarySearchTree.cpp)|Hard|
-|98|[Validate Binary Search Tree](https://oj.leetcode.com/problems/validate-binary-search-tree/)| [C++](./algorithms/cpp/validateBinarySearchTree/validateBinarySearchTree.cpp), [Java](./algorithms/java/src/validateBinarySearchTree/validateBinarySearchTree.java)|Medium|
+|98|[Validate Binary Search Tree](https://oj.leetcode.com/problems/validate-binary-search-tree/)| [C++](./algorithms/cpp/validateBinarySearchTree/validateBinarySearchTree.cpp), [Java](./algorithms/java/src/validateBinarySearchTree/validateBinarySearchTree.java), [Python](./algorithms/python/ValidateBinarySearchTree/isValidBST.py)|Medium|
 |97|[Interleaving String](https://oj.leetcode.com/problems/interleaving-string/)| [C++](./algorithms/cpp/interleavingString/interleavingString.cpp)|Hard|
 |96|[Unique Binary Search Trees](https://oj.leetcode.com/problems/unique-binary-search-trees/)| [C++](./algorithms/cpp/uniqueBinarySearchTrees/uniqueBinarySearchTrees.cpp), [Python](./algorithms/python/UniqueBinarySearchTrees/numTrees.py)|Medium|
-|95|[Unique Binary Search Trees II](https://oj.leetcode.com/problems/unique-binary-search-trees-ii/)| [C++](./algorithms/cpp/uniqueBinarySearchTrees/uniqueBinarySearchTrees.II.cpp)|Medium|
+|95|[Unique Binary Search Trees II](https://oj.leetcode.com/problems/unique-binary-search-trees-ii/)| [C++](./algorithms/cpp/uniqueBinarySearchTrees/uniqueBinarySearchTrees.II.cpp), [Python](./algorithms/python/UniqueBinarySearchTreesII/generateTrees.py)|Medium|
 |94|[Binary Tree Inorder Traversal](https://oj.leetcode.com/problems/binary-tree-inorder-traversal/)| [C++](./algorithms/cpp/binaryTreeInorderTraversal/binaryTreeInorderTraversal.cpp)|Medium|
 |93|[Restore IP Addresses](https://oj.leetcode.com/problems/restore-ip-addresses/)| [C++](./algorithms/cpp/restoreIPAddresses/restoreIPAddresses.cpp)|Medium|
-|92|[Reverse Linked List II](https://oj.leetcode.com/problems/reverse-linked-list-ii/)| [C++](./algorithms/cpp/reverseLinkedList/reverseLinkedList.II.cpp), [Java](./algorithms/java/src/reverseLinkedListII/ReverseLinkedListII.java)|Medium|
+|92|[Reverse Linked List II](https://oj.leetcode.com/problems/reverse-linked-list-ii/)| [C++](./algorithms/cpp/reverseLinkedList/reverseLinkedList.II.cpp), [Java](./algorithms/java/src/reverseLinkedListII/ReverseLinkedListII.java), [Python](./algorithms/python/ReverseLinkedListII/reverseBetween.py)|Medium|
 |91|[Decode Ways](https://oj.leetcode.com/problems/decode-ways/)| [C++](./algorithms/cpp/decodeWays/decodeWays.cpp)|Medium|
 |90|[Subsets II](https://oj.leetcode.com/problems/subsets-ii/)| [C++](./algorithms/cpp/subsets/subsets.II.cpp), [Java](./algorithms/java/src/subsets/subsetsII.java)|Medium|
 |89|[Gray Code](https://oj.leetcode.com/problems/gray-code/)| [C++](./algorithms/cpp/grayCode/grayCode.cpp)|Medium|
 |88|[Merge Sorted Array](https://oj.leetcode.com/problems/merge-sorted-array/)| [C++](./algorithms/cpp/mergeTwoSortedArray/mergeTwoSortedArray.cpp)|Easy|
 |87|[Scramble String](https://oj.leetcode.com/problems/scramble-string/)| [C++](./algorithms/cpp/scrambleString/scrambleString.cpp)|Hard|
-|86|[Partition List](https://oj.leetcode.com/problems/partition-list/)| [C++](./algorithms/cpp/partitionList/partitionList.cpp)|Medium|
+|86|[Partition List](https://oj.leetcode.com/problems/partition-list/)| [C++](./algorithms/cpp/partitionList/partitionList.cpp), [Python](./algorithms/python/PartitionList/partition.py)|Medium|
 |85|[Maximal Rectangle](https://oj.leetcode.com/problems/maximal-rectangle/)| [C++](./algorithms/cpp/maximalRectangle/maximalRectangle.cpp)|Hard|
 |84|[Largest Rectangle in Histogram](https://oj.leetcode.com/problems/largest-rectangle-in-histogram/)| [C++](./algorithms/cpp/largestRectangleInHistogram/largestRectangleInHistogram.cpp)|Hard|
 |83|[Remove Duplicates from Sorted List](https://oj.leetcode.com/problems/remove-duplicates-from-sorted-list/)| [C++](./algorithms/cpp/removeDuplicatesFromSortedList/removeDuplicatesFromSortedList.cpp)|Easy|
-|82|[Remove Duplicates from Sorted List II](https://oj.leetcode.com/problems/remove-duplicates-from-sorted-list-ii/)| [C++](./algorithms/cpp/removeDuplicatesFromSortedList/removeDuplicatesFromSortedList.II.cpp)|Medium|
+|82|[Remove Duplicates from Sorted List II](https://oj.leetcode.com/problems/remove-duplicates-from-sorted-list-ii/)| [C++](./algorithms/cpp/removeDuplicatesFromSortedList/removeDuplicatesFromSortedList.II.cpp), [Python](./algorithms/python/RemoveDuplicatesFromSortedListII/deleteDuplicates.py)|Medium|
 |81|[Search in Rotated Sorted Array II](https://oj.leetcode.com/problems/search-in-rotated-sorted-array-ii/)| [C++](./algorithms/cpp/searchInRotatedSortedArray/searchInRotatedSortedArray.II.cpp)|Medium|
 |80|[Remove Duplicates from Sorted Array II](https://oj.leetcode.com/problems/remove-duplicates-from-sorted-array-ii/)| [C++](./algorithms/cpp/removeDuplicatesFromSortedArray/removeDuplicatesFromSortedArray.II.cpp)|Medium|
 |79|[Word Search](https://oj.leetcode.com/problems/word-search/)| [C++](./algorithms/cpp/wordSearch/wordSearch.cpp)|Medium|
@@ -333,7 +336,7 @@ LeetCode
 |22|[Generate Parentheses](https://oj.leetcode.com/problems/generate-parentheses/)| [C++](./algorithms/cpp/generateParentheses/generateParentheses.cpp)|Medium|
 |21|[Merge Two Sorted Lists](https://oj.leetcode.com/problems/merge-two-sorted-lists/)| [C++](./algorithms/cpp/mergeTwoSortedList/mergeTwoSortedList.cpp)|Easy|
 |20|[Valid Parentheses](https://oj.leetcode.com/problems/valid-parentheses/)| [C++](./algorithms/cpp/validParentheses/validParentheses.cpp)|Easy|
-|19|[Remove Nth Node From End of List](https://oj.leetcode.com/problems/remove-nth-node-from-end-of-list/)| [C++](./algorithms/cpp/removeNthNodeFromEndOfList/removeNthNodeFromEndOfList.cpp)|Easy|
+|19|[Remove Nth Node From End of List](https://oj.leetcode.com/problems/remove-nth-node-from-end-of-list/)| [C++](./algorithms/cpp/removeNthNodeFromEndOfList/removeNthNodeFromEndOfList.cpp), [Python](./algorithms/python/RemoveNthNodeFromEndOfList/removeNthFromEnd.py)|Easy|
 |18|[4Sum](https://oj.leetcode.com/problems/4sum/)| [C++](./algorithms/cpp/4Sum/4Sum.cpp)|Medium|
 |17|[Letter Combinations of a Phone Number](https://oj.leetcode.com/problems/letter-combinations-of-a-phone-number/)| [C++](./algorithms/cpp/letterCombinationsOfAPhoneNumber/letterCombinationsOfAPhoneNumber.cpp)|Medium|
 |16|[3Sum Closest](https://oj.leetcode.com/problems/3sum-closest/)| [C++](./algorithms/cpp/3SumClosest/3SumClosest.cpp)|Medium|

algorithms/python/FlipBinaryTreeToMatchPreorderTraversal/flipMatchVoyage.py

@@ -0,0 +1,12 @@
+def flipMatchVoyage(self, root, voyage):
+    res = []
+    self.i = 0
+    def dfs(root):
+        if not root: return True
+        if root.val != voyage[self.i]: return False
+        self.i += 1
+        if root.left and root.left.val != voyage[self.i]:
+            res.append(root.val)
+            root.left, root.right = root.right, root.left
+        return dfs(root.left) and dfs(root.right)
+    return res if dfs(root) else [-1]

algorithms/python/InsertionSortList/insertionSortList.py

@@ -0,0 +1,19 @@
+def insertionSortList(self, head):
+    if not head: return head
+    
+    dummy = ListNode(0)
+    curr = head
+    prev = dummy
+    
+    while curr:
+        next = curr.next
+        while prev.next and prev.next.val < curr.val:
+            prev = prev.next
+        
+        curr.next = prev.next
+        prev.next = curr
+        prev = dummy
+        
+        curr = next
+    
+    return dummy.next

algorithms/python/LongestUnivaluePath/longestUnivaluePath.py

@@ -0,0 +1,11 @@
+def longestUnivaluePath(self, root):
+    self.longest = 0
+    def helper(root):
+        if not root: return 0
+        l, r = helper(root.left), helper(root.right)
+        left = (l + 1) if root.left and root.left.val == root.val else 0
+        right = (r + 1) if root.right and root.right.val == root.val else 0
+        self.longest = max(self.longest, left + right)
+        return max(left, right)
+    helper(root)
+    return self.longest

algorithms/python/PartitionList/partition.py

@@ -0,0 +1,14 @@
+def partition(self, head, x):
+    h1 = l1 = ListNode(0)
+    h2 = l2 = ListNode(0)
+    while head:
+        if head.val < x:
+            l1.next = head
+            l1 = l1.next
+        else:
+            l2.next = head
+            l2 = l2.next
+        head = head.next
+    l2.next = None
+    l1.next = h2.next
+    return h1.next

algorithms/python/PathSumIII/pathSum.py

@@ -0,0 +1,21 @@
+def pathSum(self, root, target):
+    self.result = 0
+    cache = {0:1}
+    
+    def dfs(root, currPathSum):
+        if not root: return  
+
+        currPathSum += root.val
+        oldPathSum = currPathSum - target
+
+        self.result += cache.get(oldPathSum, 0)
+        cache[currPathSum] = cache.get(currPathSum, 0) + 1
+
+
+        dfs(root.left, currPathSum)
+        dfs(root.right, currPathSum)
+
+        cache[currPathSum] -= 1
+    
+    dfs(root, 0)
+    return self.result

algorithms/python/RemoveDuplicatesFromSortedListII/deleteDuplicates.py

@@ -0,0 +1,13 @@
+def deleteDuplicates(self, head):
+    dummy = prev = ListNode(0)
+    dummy.next = head
+    while head and head.next:
+        if head.val == head.next.val:
+            while head and head.next and head.val == head.next.val:
+                head = head.next
+            head = head.next
+            prev.next = head
+        else:
+            prev = prev.next
+            head = head.next
+    return dummy.next

algorithms/python/RemoveNthNodeFromEndOfList/removeNthFromEnd.py

@@ -0,0 +1,10 @@
+def removeNthFromEnd(self, head, n):
+    slow = fast = head
+    for i in range(n):
+        fast = fast.next
+    if not fast: return head.next
+    while fast.next:
+        fast = fast.next
+        slow = slow.next
+    slow.next = slow.next.next
+    return head

algorithms/python/ReverseLinkedListII/reverseBetween.py

@@ -0,0 +1,14 @@
+def reverseBetween(self, head, m, n):
+    if not head or n == m: return head
+    p = dummy = ListNode(0)
+    dummy.next = head
+    for _ in range(m - 1):
+        p = p.next
+    tail = p.next
+    
+    for _ in range(n - m):
+        temp = p.next
+        p.next = tail.next
+        tail.next = tail.next.next
+        p.next.next = temp
+    return dummy.next

algorithms/python/SortList/sortList.py

@@ -0,0 +1,37 @@
+# merge sort:
+
+def sortList(self, head):
+    if not head or not head.next: return head
+    leftHalf, rightHalf = self.split(head)
+    left = self.sortList(leftHalf)
+    right = self.sortList(rightHalf)
+    return self.mergeSorted(left, right)
+    
+def mergeSorted(self, a, b):
+    res = dummy = ListNode(0)
+    while a and b:
+        if a.val < b.val:
+            dummy.next = a
+            dummy = a
+            a = a.next
+        else:
+            dummy.next = b
+            dummy = b
+            b = b.next
+    if not a: dummy.next = b
+    else: dummy.next = a
+
+    return res.next
+    
+def split(self, node):
+    if not node or not node.next:
+        return node, None
+    slow, fast = node, node
+    prev = None
+    while fast.next:
+        prev = slow
+        slow = slow.next
+        fast = fast.next.next
+        if not fast: break
+    prev.next = None
+    return node, slow

algorithms/python/UniqueBinarySearchTreesII/generateTrees.py

@@ -0,0 +1,24 @@
+def generateTrees(self, n):
+    if n == 0: return []
+    
+    def helper(start, end):
+        ls = []
+        if start > end:
+            ls.append(None)
+            return ls
+        if start == end:
+            ls.append(TreeNode(start))
+            return ls
+        
+        for i in range(start, end + 1):
+            left = helper(start, i - 1)
+            right = helper(i + 1, end)
+            for lnode in left:
+                for rnode in right:
+                    root = TreeNode(i)
+                    root.left = lnode
+                    root.right = rnode
+                    ls.append(root)
+        return ls
+    
+    return helper(1, n)

algorithms/python/ValidateBinarySearchTree/isValidBST.py

@@ -0,0 +1,26 @@
+# method 1: using recursion
+
+def isValidBST1(self, root, lower = float('-inf'), upper = float('inf')):
+    """
+    :type root: TreeNode
+    :rtype: bool
+    """
+    if not root: return True
+    if root.val <= lower or root.val >= upper: return False
+    return self.isValidBST(root.left, lower, min(upper, root.val)) \
+        and self.isValidBST(root.right, max(lower, root.val), upper)
+
+
+# method 2: a proper BST should have this porperty: inorder traversal is increasing
+def isValidBST2(self, root):
+    inorder = []
+    def helper(root):
+        if root:
+            helper(root.left)
+            inorder.append(root.val)
+            helper(root.right)
+            
+    helper(root)
+    for i in range(len(inorder) - 1):
+        if inorder[i + 1] <= inorder[i]: return False
+    return True