代码随想录第12天_priorityqueue pq = new priorityqueue<>((pai

150. 逆波兰表达式求值

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。 

逆波兰表达式：后缀表达式，平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 

---

如何用栈来计算出该过程？遇到操作符，那就从栈口取出元素操作，计算，再把结果压入栈

   

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
         for(String s :tokens){
             if("+".equals(s)){
                 stack.push(stack.pop() + stack.pop());
             }else if("-".equals(s)){
                 stack.push(- stack.pop() + stack.pop());
             }else if("*".equals(s)){
                 stack.push(stack.pop() * stack.pop());
             }else if("/".equals(s)){
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                 stack.push(temp2 / temp1);
         }
         else{
             stack.push(Integer.valueOf(s));
         }
         }
         return stack.pop();
    }
}

这里需要注意减法和除法，因为栈先进后出的问题有顺序问题，所以先存下两个出栈的内容，然后再进行计算。   

239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

这是使用单调队列的经典题目。

难点是如何求一个区间里的最大值呢？ 暴力解法 遍历一遍的过程中每次从窗口中在找到最大的数值，这样很明显是O(n × k)的算法

为了提高复杂度此时我们需要一个队列，这个队列呢，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么

这个队列应该是这样：有pop 有push 有front   调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值。

class MyQueue{
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时，比较当前要弹出的数值是否等于队列出口数值，相等弹出
    void poll(int val){
        if(!deque.isEmpty() && val == deque.peek()){
            deque.poll();
        }}
    void add(int val){
        while(!deque.isEmpty() && val > deque.getLast()){
            deque.removeLast();
        }
        deque.add(val);
    }
    int peek(){
        return deque.peek();
    }
    
    //添加元素，要添加的元素大于入口元素，就将入口元素弹出
    //队列元素 3 1 2，比1大所以1弹出，
}
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();
        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 个高频元素  

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

主要涉及三块内容：1. 统计元素出现频率  2. 对频率排序  3.找出前k个高频元素

统计元素出现频率 用Hashmap 计数， 

优先级队列：   

我们可以利用堆的思想：建立一个小顶堆，然后遍历「出现次数数组」：

如果堆的元素个数小于 kk，就可以直接插入堆中。
如果堆的元素个数等于 kk，则检查堆顶与当前出现次数的大小。如果堆顶更大，说明至少有 kk 个数字的出现次数比当前值大，故舍弃当前值；否则，就弹出堆顶，并将当前值插入堆中。

 

 

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        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;
    }
    }