第三周作业#26

Author: huanghaifeng

Week_03/id_26/LeetCode_102_26.py

@@ -0,0 +1,64 @@
+#
+# @lc app=leetcode.cn id=102 lang=python
+#
+# [102] 二叉树的层次遍历
+#
+# https://leetcode-cn.com/problems/binary-tree-level-order-traversal/description/
+#
+# algorithms
+# Medium (56.47%)
+# Likes:    213
+# Dislikes: 0
+# Total Accepted:    28.4K
+# Total Submissions: 50.2K
+# Testcase Example:  '[3,9,20,null,null,15,7]'
+#
+# 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。
+#
+# 例如:
+# 给定二叉树: [3,9,20,null,null,15,7],
+#
+# ⁠   3
+# ⁠  / \
+# ⁠ 9  20
+# ⁠   /  \
+# ⁠  15   7
+#
+#
+# 返回其层次遍历结果：
+#
+# [
+# ⁠ [3],
+# ⁠ [9,20],
+# ⁠ [15,7]
+# ]
+#
+#
+#
+# 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 levelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        layer, ans = [root], []
+        while layer:
+            next_layer, vals = [], []
+            for node in layer:
+                vals.append(node.val)
+                if node.left:
+                    next_layer.append(node.left)
+                if node.right:
+                    next_layer.append(node.right)
+            layer, ans = next_layer, ans + [vals]
+        return ans

Week_03/id_26/LeetCode_104_26.py

@@ -0,0 +1,50 @@
+#
+# @lc app=leetcode.cn id=104 lang=python
+#
+# [104] 二叉树的最大深度
+#
+# https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/description/
+#
+# algorithms
+# Easy (69.23%)
+# Likes:    297
+# Dislikes: 0
+# Total Accepted:    51.2K
+# Total Submissions: 73.9K
+# Testcase Example:  '[3,9,20,null,null,15,7]'
+#
+# 给定一个二叉树，找出其最大深度。
+#
+# 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+#
+# 说明: 叶子节点是指没有子节点的节点。
+#
+# 示例：
+# 给定二叉树 [3,9,20,null,null,15,7]，
+#
+# ⁠   3
+# ⁠  / \
+# ⁠ 9  20
+# ⁠   /  \
+# ⁠  15   7
+#
+# 返回它的最大深度 3 。
+#
+#
+# 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 maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

Week_03/id_26/LeetCode_107_26.py

@@ -0,0 +1,63 @@
+#
+# @lc app=leetcode.cn id=107 lang=python
+#
+# [107] 二叉树的层次遍历 II
+#
+# https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/description/
+#
+# algorithms
+# Easy (60.77%)
+# Likes:    108
+# Dislikes: 0
+# Total Accepted:    17.6K
+# Total Submissions: 28.8K
+# Testcase Example:  '[3,9,20,null,null,15,7]'
+#
+# 给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
+#
+# 例如：
+# 给定二叉树 [3,9,20,null,null,15,7],
+#
+# ⁠   3
+# ⁠  / \
+# ⁠ 9  20
+# ⁠   /  \
+# ⁠  15   7
+#
+#
+# 返回其自底向上的层次遍历为：
+#
+# [
+# ⁠ [15,7],
+# ⁠ [9,20],
+# ⁠ [3]
+# ]
+#
+#
+#
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+import collections
+
+
+class Solution(object):
+    def levelOrderBottom(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        queue, ans = collections.deque([(root, 0)]), []
+        while queue:
+            node, level = queue.popleft()
+            if node:
+                if len(ans) < level+1:
+                    ans.insert(0, [])
+                ans[-level-1] += [node.val]
+                queue.append((node.left, level+1))
+                queue.append((node.right, level+1))
+        return ans

Week_03/id_26/LeetCode_111_26.py

@@ -0,0 +1,55 @@
+#
+# @lc app=leetcode.cn id=111 lang=python
+#
+# [111] 二叉树的最小深度
+#
+# https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/description/
+#
+# algorithms
+# Easy (38.70%)
+# Likes:    125
+# Dislikes: 0
+# Total Accepted:    19K
+# Total Submissions: 49K
+# Testcase Example:  '[3,9,20,null,null,15,7]'
+#
+# 给定一个二叉树，找出其最小深度。
+#
+# 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
+#
+# 说明: 叶子节点是指没有子节点的节点。
+#
+# 示例:
+#
+# 给定二叉树 [3,9,20,null,null,15,7],
+#
+# ⁠   3
+# ⁠  / \
+# ⁠ 9  20
+# ⁠   /  \
+# ⁠  15   7
+#
+# 返回它的最小深度  2.
+#
+#
+# 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 minDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+        left = self.minDepth(root.left)
+        right = self.minDepth(root.right)
+        if not left or not right:
+            return 1 + left + right
+        return 1 + min(left, right)

Week_03/id_26/LeetCode_200_26.py

@@ -0,0 +1,74 @@
+#
+# @lc app=leetcode.cn id=200 lang=python
+#
+# [200] 岛屿数量
+#
+# https://leetcode-cn.com/problems/number-of-islands/description/
+#
+# algorithms
+# Medium (43.81%)
+# Likes:    167
+# Dislikes: 0
+# Total Accepted:    16K
+# Total Submissions: 36.5K
+# Testcase Example:  '[["1","1","1","1","0"],["1","1","0","1","0"],["1","1","0","0","0"],["0","0","0","0","0"]]'
+#
+# 给定一个由 '1'（陆地）和
+# '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。
+#
+# 示例 1:
+#
+# 输入:
+# 11110
+# 11010
+# 11000
+# 00000
+#
+# 输出: 1
+#
+#
+# 示例 2:
+#
+# 输入:
+# 11000
+# 11000
+# 00100
+# 00011
+#
+# 输出: 3
+#
+#
+#
+
+
+class Solution(object):
+    def numIslands(self, grid):
+        """
+        :type grid: List[List[str]]
+        :rtype: int
+        """
+
+        dx, dy = [1, -1, 0, 0], [0, 0, 1, -1]
+
+        def sink(i, j):
+            if i < 0 or i == len(grid) or j < 0 or j == len(
+                    grid[i]) or grid[i][j] == '0':
+                return 0
+            grid[i][j] = '0'
+            for k in range(4):
+                sink(i + dx[k], j + dy[k])
+            return 1
+
+        ans = 0
+        for i in range(len(grid)):
+            for j in range(len(grid[i])):
+                ans += sink(i, j)
+        return ans
+
+
+# print(Solution().numIslands([["1", "1", "1", "1", "0"],
+#                              ["1", "1", "0", "1", "0"],
+#                              ["1", "1", "0", "0", "0"],
+#                              ["0", "0", "0", "0", "0"]]))
+
+# print(Solution().numIslands([]))

Week_03/id_26/LeetCode_295_26.py

@@ -0,0 +1,83 @@
+#
+# @lc app=leetcode.cn id=295 lang=python
+#
+# [295] 数据流的中位数
+#
+# https://leetcode-cn.com/problems/find-median-from-data-stream/description/
+#
+# algorithms
+# Hard (35.43%)
+# Likes:    46
+# Dislikes: 0
+# Total Accepted:    3.3K
+# Total Submissions: 9.2K
+# Testcase Example:  '["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]\n[[],[1],[2],[],[3],[]]'
+#
+# 中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。
+#
+# 例如，
+#
+# [2,3,4] 的中位数是 3
+#
+# [2,3] 的中位数是 (2 + 3) / 2 = 2.5
+#
+# 设计一个支持以下两种操作的数据结构：
+#
+#
+# void addNum(int num) - 从数据流中添加一个整数到数据结构中。
+# double findMedian() - 返回目前所有元素的中位数。
+#
+#
+# 示例：
+#
+# addNum(1)
+# addNum(2)
+# findMedian() -> 1.5
+# addNum(3)
+# findMedian() -> 2
+#
+# 进阶:
+#
+#
+# 如果数据流中所有整数都在 0 到 100 范围内，你将如何优化你的算法？
+# 如果数据流中 99% 的整数都在 0 到 100 范围内，你将如何优化你的算法？
+#
+# 
+#
+"""
+维护大顶堆、小顶堆，满足以下条件：
+
+大顶堆中数字的个数 - 小顶堆数字的个数 = 0 or 1
+大顶堆的最大值 <= 小顶堆的最小值
+当长度为偶数时，中位数为大小顶堆的平均数 当长度为奇数时，中位数为大顶堆的最大值
+
+注：python的heapq中只有小顶堆，所以存入时取负数则为大顶堆
+"""
+import heapq
+
+
+class MedianFinder(object):
+    def __init__(self):
+        """
+        initialize your data structure here.
+        """
+        self.len = 0
+        self.max_heap, self.min_heap = [], []
+
+    def addNum(self, num):
+        """
+        :type num: int
+        :rtype: None
+        """
+        self.len += 1
+        heapq.heappush(self.min_heap, -heapq.heappushpop(self.max_heap, num))
+        if len(self.min_heap) > len(self.max_heap):
+            heapq.heappush(self.max_heap, -heapq.heappop(self.min_heap))
+
+    def findMedian(self):
+        """
+        :rtype: float
+        """
+        if self.len & 1 == 0:
+            return (self.max_heap[0] - self.min_heap[0]) / 2.0
+        return self.max_heap[0]