复习

Author: gonearewe

110. 平衡二叉树.py

@@ -0,0 +1,39 @@
+# 给定一个二叉树，判断它是否是高度平衡的二叉树。
+# 本题中，一棵高度平衡二叉树定义为：
+# 一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1 。
+#
+# 示例 1：
+# 输入：root = [3,9,20,null,null,15,7]
+# 输出：true
+#
+# 示例 2：
+# 输入：root = [1,2,2,3,3,null,null,4,4]
+# 输出：false
+#
+# 示例 3：
+# 输入：root = []
+# 输出：true
+#
+# 提示：
+# 树中的节点数在范围 [0, 5000] 内
+# -104 <= Node.val <= 104
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def isBalanced(self, root: TreeNode) -> bool:
+        def dfs(node: TreeNode) -> int:
+            if node is None:
+                return 0
+            l, r = dfs(node.left), dfs(node.right)
+            if l == -1 or r == -1 or abs(l - r) > 1:
+                return -1
+            return max(l, r) + 1
+
+        return dfs(root) != -1

141. 环形链表.py

@@ -0,0 +1,47 @@
+# 给定一个链表，判断链表中是否有环。
+#
+# 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。
+# 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置
+# （索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
+# 注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
+# 如果链表中存在环，则返回 true 。 否则，返回 false 。
+#
+# 进阶：
+# 你能用 O(1)（即，常量）内存解决此问题吗？
+#
+# 示例 1：
+# 输入：head = [3,2,0,-4], pos = 1
+# 输出：true
+# 解释：链表中有一个环，其尾部连接到第二个节点。
+#
+# 示例 2：
+# 输入：head = [1,2], pos = 0
+# 输出：true
+# 解释：链表中有一个环，其尾部连接到第一个节点。
+#
+# 示例 3：
+# 输入：head = [1], pos = -1
+# 输出：false
+# 解释：链表中没有环。
+#
+# 提示：
+# 链表中节点的数目范围是 [0, 104]
+# -105 <= Node.val <= 105
+# pos 为 -1 或者链表中的一个 有效索引 。
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def hasCycle(self, head: ListNode) -> bool:
+        if head is None or head.next is None:
+            return False
+        slow, fast = head, head.next
+        while slow != fast:
+            if fast is None or fast.next is None:
+                return False
+            slow = slow.next
+            fast = fast.next.next
+        return True

33. 搜索旋转排序数组.py

@@ -0,0 +1,38 @@
+# 整数数组 nums 按升序排列，数组中的值互不相同 。
+# 在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，
+# 使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]
+# （下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2]。
+#
+# 给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，
+# 则返回它的下标，否则返回 -1。
+#
+# 示例 1：
+# 输入：nums = [4,5,6,7,0,1,2], target = 0
+# 输出：4
+#
+# 示例 2：
+# 输入：nums = [4,5,6,7,0,1,2], target = 3
+# 输出：-1
+#
+# 示例 3：
+# 输入：nums = [1], target = 0
+# 输出：-1
+#
+# 提示：
+# 1 <= nums.length <= 5000
+# -10^4 <= nums[i] <= 10^4
+# nums 中的每个值都 独一无二
+# 题目数据保证 nums 在预先未知的某个下标上进行了旋转
+# -10^4 <= target <= 10^4
+
+# 进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        l, r = 0, len(nums) - 1
+        while l < r:
+            mid = (l + r) // 2
+            if nums[l] <= target <= nums[mid] or target <= nums[mid] < nums[r] or nums[mid] < nums[l] <= target:
+                r = mid
+            else:
+                l = mid + 1
+        return l if nums[l] == target else -1

347. 前 K 个高频元素.py

@@ -0,0 +1,34 @@
+# 给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。
+# 你可以按 任意顺序 返回答案。
+#
+# 示例 1:
+# 输入: nums = [1,1,1,2,2,3], k = 2
+# 输出: [1,2]
+#
+# 示例 2:
+# 输入: nums = [1], k = 1
+# 输出: [1]
+#
+# 提示：
+# 1 <= nums.length <= 105
+# k 的取值范围是 [1, 数组中不相同的元素的个数]
+# 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的
+#
+# 进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
+
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        cnt_m = {}
+        for num in nums:
+            if num not in cnt_m:
+                cnt_m[num] = 0
+            cnt_m[num] += 1
+            
+        li = []
+        heapq.heapify(li)
+        for cnt, e in cnt_m.items():
+            if len(li) < k:
+                heapq.heappush(li, (e, cnt))
+            else:
+                heapq.heappushpop(li, (e, cnt))
+        return [e for _, e in li]