150. 逆波蘭表示式求值
給你一個字串陣列 tokens ，表示一個根據 逆波蘭表示法 表示的算術表示式。
請你計算該表示式。返回一個表示表示式值的整數。
注意：
- 有效的算符為
'+'、'-'、'*'和'/'。 - 每個運算元（運算物件）都可以是一個整數或者另一個表示式。
- 兩個整數之間的除法總是 向零截斷 。
- 表示式中不含除零運算。
- 輸入是一個根據逆波蘭表示法表示的算術表示式。
- 答案及所有中間計算結果可以用 32 位 整數表示。
示例 1：
輸入：tokens = ["2","1","+","3","*"]
輸出：9
解釋：該算式轉化為常見的中綴算術表示式為：((2 + 1) * 3) = 9
示例 2：
輸入：tokens = ["4","13","5","/","+"]
輸出：6
解釋：該算式轉化為常見的中綴算術表示式為：(4 + (13 / 5)) = 6
字尾轉中綴,使用棧即可
程式碼如下:
@Test
public void test01() {
String[] str = new String[]{"2", "1", "+", "3", "*"};
System.out.println("逆波蘭表示式的結果是:" + evalRPN(str));
}
public int evalRPN(String[] tokens) {
ArrayDeque<Integer> stack = new ArrayDeque<>();
for (String str : tokens) {
switch (str) {
case "+" -> stack.push(stack.pop() + stack.pop());
case "-" -> stack.push(-stack.pop() + stack.pop());
case "*" -> stack.push(stack.pop() * stack.pop());
case "/" -> {
int num1 = stack.pop();
int num2 = stack.pop();
stack.push(num2 / num1);
}
default -> stack.push(Integer.valueOf(str));
}
}
return stack.pop();
}
239. 滑動視窗最大值
給你一個整數陣列 nums，有一個大小為 k 的滑動視窗從陣列的最左側移動到陣列的最右側。你只可以看到在滑動視窗內的 k 個數字。滑動視窗每次只向右移動一位。
返回 滑動視窗中的最大值 。
示例 1：
輸入：nums = [1,3,-1,-3,5,3,6,7], k = 3
輸出：[3,3,5,5,6,7]
解釋：
滑動視窗的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
示例 2：
輸入：nums = [1], k = 1
輸出：[1]
思路 : 這是我第一次接觸到單調佇列,這次用到的輔助資料結構是遞減單調佇列.
遍歷陣列nums,在將i位置放入單調佇列前,需要判斷這個i位置能不能放入單調數列,以及放入i位置之前單調佇列需要做哪些調整,才能繼續維繫單調佇列
第一,如果單調佇列的頭元素已經超過了滑動視窗邊界i-k+1且頭元素不為空,那麼就需要把頭元素彈出,以此迴圈,直到頭元素在滑動視窗內
第二,如果這次要加入的i位置在nums中的值是大於目前單調佇列的頭元素在nums中的值,那麼就不符合單調佇列了,就需要把原來的小的頭元素彈出,以此迴圈比較頭元素和i位置在nums中對應的值,進行彈出操作,直到頭元素對應的值比i對應的值大,或者頭元素為空為止
於是就可以把i位置安心地放入單調佇列中了
但是
還需要考慮一個問題,我的結果集什麼時候開始收集?
當然是從i的值等於k-1開始收集,收集n-k+1次即可,因此需要在入隊操作後,加上對於結果集res的操作,這個操作當然是將本次滑動視窗對應的單調佇列的出口元素在nums中對應的值賦值給res
最後,返回結果集res即可
程式碼如下:
@Test
public void test02(){
int[] nums = {1,3,-1,-3,5,3,6,7};
int k = 3;
int[] res = maxSlidingWindow(nums, k);
System.out.println(Arrays.toString(res));
}
public int[] maxSlidingWindow(int[] nums, int k) {
ArrayDeque<Integer> deuqe = new ArrayDeque<>();
int n = nums.length;
int[] res = new int[n - k + 1];
int index = 0;
for (int i = 0; i < n; i++) {
while (!deuqe.isEmpty() && deuqe.peek() < (i - k + 1)) {
deuqe.poll();
}
while (!deuqe.isEmpty() && nums[deuqe.peekLast()] < nums[i]) {
deuqe.pollLast();
}
deuqe.offer(i);
if (i >= k - 1) {
res[index++] = nums[deuqe.peek()];
}
}
return res;
}
347.前 K 個高頻元素
給你一個整數陣列 nums 和一個整數 k ，請你返回其中出現頻率前 k 高的元素。你可以按 任意順序 返回答案。
示例 1:
輸入: nums = [1,1,1,2,2,3], k = 2
輸出: [1,2]
示例 2:
輸入: nums = [1], k = 1
輸出: [1]
關於大頂堆和小頂堆在java中資料結構知識如下:
在Java中，大頂堆（Max Heap）和小頂堆（Min Heap）是兩種常用的基於二叉樹的資料結構，它們都是堆（Heap）這種特殊完全二叉樹的實現。堆通常用於實現優先佇列，其中大頂堆的根節點是堆中的最大元素，而小頂堆的根節點是堆中的最小元素。Java標準庫中沒有直接以“大頂堆”或“小頂堆”命名的類，但PriorityQueue類可以實現這兩種堆的功能。
PriorityQueue 類
java.util.PriorityQueue 是一個基於優先順序堆的無界優先順序佇列。預設情況下，PriorityQueue 是一個小頂堆，但是你可以透過提供一個自定義的比較器（Comparator）來讓它表現為大頂堆。
小頂堆示例
import java.util.PriorityQueue;
public class MinHeapExample {
public static void main(String[] args) {
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
minHeap.add(10);
minHeap.add(5);
minHeap.add(20);
minHeap.add(1);
while (!minHeap.isEmpty()) {
System.out.println(minHeap.poll()); // 依次輸出 1, 5, 10, 20
}
}
}
大頂堆示例
要使用PriorityQueue實現大頂堆，你需要提供一個自定義的比較器，該比較器會反轉元素的自然順序（或者任何你想要的順序）。
import java.util.Comparator;
import java.util.PriorityQueue;
public class MaxHeapExample {
public static void main(String[] args) {
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
maxHeap.add(10);
maxHeap.add(5);
maxHeap.add(20);
maxHeap.add(1);
while (!maxHeap.isEmpty()) {
System.out.println(maxHeap.poll()); // 依次輸出 20, 10, 5, 1
}
}
}
思路 : 這是我第一次在題目中使用到小頂堆這個資料結構,但是在這個題中又出奇地好用,因為只需要入堆時判斷當前頻率值是否大於小頂堆的堆頂的頻率值,如果大於,那麼就把小頂堆中的堆頂元素彈出,將當前的值放入堆中,否則則不做操作,以此迴圈
程式碼如下:
@Test
public void test03() {
int[] nums = new int[]{1, 1, 1, 2, 2, 3};
int k = 2;
int[] res = topKFrequent(nums, k);
System.out.println("前" + k + "個高頻元素是 : " + Arrays.toString(res));
}
public int[] topKFrequent(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>(); //用來儲存nums中的元素和其出現次數的對映關係
for (int i = 0; i < nums.length; i++) {
map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
}
PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(pri -> pri[1]));
//Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
if (queue.size() < k) {
queue.add(new int[]{entry.getKey(), entry.getValue()});
} else {
//assert queue.peek() != null;
if (!queue.isEmpty() && entry.getValue() > queue.peek()[1]) {
queue.poll();
queue.add(new int[]{entry.getKey(), entry.getValue()});
}
}
}
int[] res = new int[k];
for (int i = k - 1; i >= 0; i--) {
//assert queue.peek() != null;
if (!queue.isEmpty()) res[i] = queue.poll()[0];
}
return res;
}