Day10(棧與佇列) | 150. 逆波蘭表示式求值 239. 滑動視窗最大值 347.前 K 個高頻元素

flydandelion發表於2024-07-15
佇列

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;
    }

相關文章