366_Find_Leaves_of_Binary_Tree

369_Plus_One_Linked_List

Author: qiyuangong

README.md

@@ -109,7 +109,9 @@
 [Python](https://github.com/qiyuangong/leetcode/blob/master/python/346_Moving_Average_from_Data_Stream.py) | fix-sized queue or dequeue, O(1) and O(n) |
 | 351 | [Android Unlock Patterns](https://leetcode.com/problems/android-unlock-patterns/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/351_Android_Unlock_Patterns.py) | Backtracking, O(n!) and O(n) |
 | 359 | [Logger Rate Limiter](https://leetcode.com/problems/logger-rate-limiter/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/359_Logger_Rate_Limiter.py) | 1. hash which stores the latest timestamp, O(1) and O(n)<br>2. Using Priority queue to remove older logs, O(n) and O(n) |
+| 366 | [Find Leaves of Binary Tree](https://leetcode.com/problems/find-leaves-of-binary-tree/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/366_Find_Leaves_of_Binary_Tree.py) | 1. Set or hash to check leaft, O(n^2) and O(n)<br>2. Recursively check level and return them, O(n) and O(n)|
 | 368 | [Largest Divisible Subset](https://leetcode.com/problems/largest-divisible-subset/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/368_Largest_Divisible_Subset.py) | Sort and generate x subset with previous results, O(n^2) and O(n^2) |
+| 369 | [Plus One Linked List](https://leetcode.com/problems/plus-one-linked-list/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/369_Plus_One_Linked_List.py) | 1. Stack or list that store the list, O(n) and O(n)<br>2. Two points, the first to the tail, the second to the latest place that is not 9, O(n) and O(1) |
 | 370 | [Range Addition](https://leetcode.com/problems/range-addition/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/370_Range_Addition.py) | Interval problem with cumulative sums, O(n + k) and O(n) |
 | 384 | [Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/384_Shuffle_an_Array.py) | Fisher–Yates shuffle, O(n) and O(n) |
 | 388 | [Longest Absolute File Path](https://leetcode.com/problems/longest-absolute-file-path/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/388_Longest_Absolute_File_Path.py) | Store last length and rindex, O(n) and O(n) |

python/366_Find_Leaves_of_Binary_Tree.py

@@ -0,0 +1,50 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+
+class Solution(object):
+    # def findLeaves(self, root):
+    #     """
+    #     :type root: TreeNode
+    #     :rtype: List[List[int]]
+    #     """
+    #     res = []
+    #     if root is None:
+    #         return []
+    #     stack = [root]
+    #     check_set = set()
+    #     while len(stack) > 0:
+    #         curr = stack.pop()
+    #         check_set.add(curr)
+    #         if curr.left:
+    #             stack.append(curr.left)
+    #         if curr.right:
+    #             stack.append(curr.right)
+    #     while len(check_set) > 0:
+    #         curr = []
+    #         for node in check_set:
+    #             if (node.left is None or node.left not in check_set) and\
+    #                (node.right is None or node.right not in check_set):
+    #                 curr.append(node)
+    #         res.append([node.val for node in curr])
+    #         for node in curr:
+    #             check_set.remove(node)
+    #     return res
+
+    def findLeaves(self, root):
+        res = []
+        self.findLeaves_helper(root, res)
+        return res
+
+    def findLeaves_helper(self, node, res):
+        if node is None:
+            return -1
+        level = 1 + max(self.findLeaves_helper(node.left, res), self.findLeaves_helper(node.right, res))
+        if len(res) < level + 1:
+            res.append([])
+        res[level].append(node.val)
+        return level

python/369_Plus_One_Linked_List.py

@@ -0,0 +1,35 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
+class Solution(object):
+    def plusOne(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        dummy = ListNode(0)
+        dummy.next = head
+        place_stop, tail = dummy, dummy
+        # find the tail
+        while tail.next is not None:
+            tail = tail.next
+            if tail.val != 9:
+                place_stop = tail
+        if tail.val != 9:
+            # done
+            tail.val += 1
+        else:
+            # not yet
+            place_stop.val += 1
+            place_stop = place_stop.next
+            # set all node behind this place to zero
+            while place_stop is not None:
+                place_stop.val = 0
+                place_stop = place_stop.next
+        if dummy.val == 0:
+            return dummy.next
+        return dummy