Leetcode-day10-栈和队列

150. 逆波兰表达式求值

思路，从左往右遍历，遇到+-*/，就弹出两个元素，并把运算结果压入栈中，其他的压入栈。

需要注意的是：1. 先出栈的是右操作数，后出栈的是左操作数

2.String类型转int类型的时候用Integer.parseInt();

class Solution {
public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        
        for (String token : tokens) {
            switch (token) {
                case "+":
                    int addRight = stack.pop();
                    int addLeft = stack.pop();
                    stack.push(addLeft + addRight);
                    break;
                case "-":
                    int subRight = stack.pop();
                    int subLeft = stack.pop();
                    stack.push(subLeft - subRight);
                    break;
                case "*":
                    int mulRight = stack.pop();
                    int mulLeft = stack.pop();
                    stack.push(mulLeft * mulRight);
                    break;
                case "/":
                    int divRight = stack.pop();
                    int divLeft = stack.pop();
                    stack.push(divLeft / divRight);
                    break;
                default:
                    stack.push(Integer.parseInt(token));
                    break;
            }
        }
        
        return stack.pop();
    }
}

239. 滑动窗口最大值

我们自己写一个队列的数据结构，新加入一个元素就push，然后把滑动窗口内不需要的元素pop掉，还有一个函数能够获取到滑动窗口内的最大值。注意在队列中维护的是窗口内的元素，而窗口内的元素其实只需要维护一个递减序列。

Deque是双端队列，可以用它实现Queue或者Stack。Deque deque = new LinkedList()

class MyQueue {
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
    //同时判断队列当前是否为空
    void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            deque.poll();
        }
    }
    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
    //保证队列元素单调递减
    //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
    void add(int val) {
        while (!deque.isEmpty() && val > deque.getLast()) {
            deque.removeLast();
        }
        deque.add(val);
    }
    //队列队顶元素始终为最大值
    int peek() {
        return deque.peek();
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1) {
            return nums;
        }
        int len = nums.length - k + 1;
        //存放结果元素的数组
        int[] res = new int[len];
        int num = 0;
        //自定义队列
        MyQueue myQueue = new MyQueue();
        //先将前k的元素放入队列
        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }
        res[num++] = myQueue.peek();
        for (int i = k; i < nums.length; i++) {
            //滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
            myQueue.poll(nums[i - k]);
            //滑动窗口加入最后面的元素
            myQueue.add(nums[i]);
            //记录对应的最大值
            res[num++] = myQueue.peek();
        }
        return res;
    }
}

347. 前 K 个高频元素

hashmap

容易想到的一个思路就是用hashmap，key放的是元素，value放的是出现频次。然后用value做排序，返回前k个key。怎么用hashmap的value排序还是需要注意的。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer,Integer> hashmap = new HashMap<>();
        for(int i:nums){
            hashmap.put(i,hashmap.getOrDefault(i,0)+1);
        }
        List<Map.Entry<Integer, Integer>> entryList = new ArrayList<>(hashmap.entrySet());
        
        entryList.sort((a, b) -> b.getValue() - a.getValue());
        
        int[] result = new int[k];
        for (int i = 0; i < k; i++) {
            result[i] = entryList.get(i).getKey();
        }
        
        return result;
    }
}

大顶堆

同样的还是用hashmap存储元素和出现的次数，新建一个优先级队列（大顶堆），以此取出前k个

    public int[] topKFrequent1(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数
        for (int num : nums) {
            map.put(num, map.getOrDefault(num,0) + 1);
        }
        //在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
        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[] ans = new int[k];
        for (int i = 0; i < k; i++) { //依次从队头弹出k个,就是出现频率前k高的元素
            ans[i] = pq.poll()[0];
        }
        return ans;
    }

小顶堆

小顶堆只需要维护k个大小，如果没满就加入，满了就pop，这个时候移除了出现次数最小的，这样循环剩下的就是k个高频元素，但是这样的优先级队列里是倒序的，注意最后需要转，新建一个res数组，倒着往进放

    public int[] topKFrequent2(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>(); //key为数组元素值,val为对应出现次数
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        //在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) { //小顶堆只需要维持k个元素有序
            if (pq.size() < k) { //小顶堆元素个数小于k个时直接加
                pq.add(new int[]{entry.getKey(), entry.getValue()});
            } else {
                if (entry.getValue() > pq.peek()[1]) { //当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                    pq.poll(); //弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
                    pq.add(new int[]{entry.getKey(), entry.getValue()});
                }
            }
        }
        int[] ans = new int[k];
        for (int i = k - 1; i >= 0; i--) { //依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
            ans[i] = pq.poll()[0];
        }
        return ans;
    }