239. 滑动窗口最大值
题目链接:https://leetcode.cn/problems/sliding-window-maximum/
文档讲解:https://programmercarl.com/0239.%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BC.html
视频讲解:https://www.bilibili.com/video/BV1XS4y1p7qj
思路
- 需要使用Deque来自己构造一个单调队列。
- 当单调队列push时,如果队列里的值小于要加入的值,就将前面的值弹出,保证队列中的数是单调递减的。
- 当单调队列pop时,需要保证弹出的值与本该弹出的值相等,否则可能之前就被弹出了,这次就不操作。
- 最后,每次获得最大值,其实都是在获取队头的值。
代码
class Solution {
public class MyQueue {
Deque<Integer> deque = new LinkedList<>();
public int getMaxValue() {
return deque.peek();
}
public void push(int val) {
while (!deque.isEmpty() && val > deque.getLast()) deque.removeLast();
deque.add(val);
}
public void pop(int val) {
if (!deque.isEmpty() && val == deque.peek()) deque.poll();
}
}
public int[] maxSlidingWindow(int[] nums, int k) {
if(nums.length == 1) return nums;
MyQueue myQueue = new MyQueue();
int[] res = new int[nums.length - k + 1];
int num = 0;
for (int i = 0; i < k; i++) {
myQueue.push(nums[i]);
}
res[num++] = myQueue.getMaxValue();
for (int i = k; i < nums.length; i++) {
myQueue.pop(nums[i - k]);
myQueue.push(nums[i]);
res[num++] = myQueue.getMaxValue();
}
return res;
}
}
分析:时间复杂度:O(n),空间复杂度:O(k),自己定义了最大长度为k的辅助单调队列。
#347.前 K 个高频元素
题目链接:https://leetcode.cn/problems/top-k-frequent-elements/
文档讲解:https://programmercarl.com/0347.%E5%89%8DK%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解:https://www.bilibili.com/video/BV1Xg41167Lz
思路
- 定义一个PriorityQueue的大顶堆,先用Map统计元素出现个数,然后放入大顶堆中,大顶堆中先输出大的数,所以直接输出前k个数。
- 注意大顶堆的定义方法
PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1])
。
代码
class Solution {
public int[] topKFrequent(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
}
PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
pq.add(new int[]{entry.getKey(), entry.getValue()});
}
int[] res = new int[k];
for (int i = 0; i < k; i++) res[i] = pq.poll()[0];
return res;
}
}
分析:时间复杂度:O(nlogn),空间复杂度:O(n)。
时间复杂度分析
-
构建频率表:
for (int i = 0; i < nums.length; i++) { map.put(nums[i], map.getOrDefault(nums[i], 0) + 1); }
这部分代码使用一个
for
循环遍历数组nums
,构建一个哈希表map
,记录每个数字出现的频率。这个步骤的时间复杂度是O(n)
,其中n
是数组nums
的长度。 -
构建优先队列:
PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]); for (Map.Entry<Integer, Integer> entry : map.entrySet()) { pq.add(new int[]{entry.getKey(), entry.getValue()}); }
这部分代码遍历频率表,将所有元素及其频率插入优先队列
pq
。由于map
最多包含n
个不同的元素,因此这个步骤的时间复杂度是O(m log m)
,其中m
是哈希表map
的大小,最多为n
。 -
获取前k个频繁元素:
int[] res = new int[k]; for (int i = 0; i < k; i++) res[i] = pq.poll()[0];
这部分代码从优先队列中提取前
k
个元素,每次提取操作的时间复杂度是O(log m)
,所以总的时间复杂度是O(k log m)
。
综合起来,整体时间复杂度为:O(n) + O(m \log m) + O(k \log m)
由于m
最大为n
,可以简化为:O(n) + O(n \log n) + O(k \log n)
在最坏情况下,时间复杂度为:O(n \log n)
空间复杂度分析
-
哈希表的空间:
Map<Integer, Integer> map = new HashMap<>();
哈希表
map
存储每个数字及其频率,最多存储n
个元素,因此其空间复杂度为O(n)
。 -
优先队列的空间:
PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
优先队列
pq
存储最多n
个元素(每个元素是一个大小为2的数组),其空间复杂度为O(n)
。 -
结果数组的空间:
int[] res = new int[k];
结果数组
res
存储k
个元素,其空间复杂度为O(k)
。
综合起来,整体空间复杂度为:O(n) + O(n) + O(k)
在最坏情况下,空间复杂度为:O(n)