代码随想录算法训练营第十一天（LeetCode150.逆波兰表达式求值；LeetCode239.滑动窗口最大值；LeetCode347.前K个高频元素）

LeetCode 150. 逆波兰表达式求值

题目链接：逆波兰表达式求值题目链接

思路

主要是要理解逆波兰表达式的定义，在理解了逆波兰表达式的定义后，使用栈就可以直接做了。
逆波兰表达式是一种后缀表达式，所谓后缀就是指运算符写在后面。
平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点：
1.去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
2.适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。

代码

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

LeetCode 239. 滑动窗口最大值

题目链接：滑动窗口最大值题目链接

思路

自己设计一个单调队列，有三个函数 pop 函数、push 函数和 getMaxValue 函数，每次将一个元素 push 进入单调队列，如果单调队列现存的元素全部小于 push 进来的元素，那么单调队列现存的元素全部 pop 出去，同时，如果 push 现存的元素后，单调队列中的元素个数大于 k 的时候，那么也要 pop 元素出去，这样可以保证单调队列队头元素就是我们想要获得的最大值，getMaxValue 函数就是获取单调队列的队头元素。

代码

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

LeetCode 347. 前 k 个高频元素

题目链接：前k个高频元素题目链接

思路

首先将数组里面的元素存入一个 Map 键值对中，键是数组的元素，值是数组元素出现的频率。然后设计一个小顶堆，大小被限制为 k，将 Map 键值对存入小顶堆中，对 Map 的值进行小顶堆排序，小顶堆是先弹出频率较小的元素，所以数组存储要倒序存储。

代码

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);
        }
        PriorityQueue<int[]> pq=new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
        for(Map.Entry<Integer,Integer>entry:map.entrySet())
        {
            if(pq.size()<k)
                pq.add(new int[]{entry.getKey(),entry.getValue()});
            else
            {
                if(entry.getValue()>pq.peek()[1])
                {
                    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;

    }
}