代码随想录算法训练营第13天 | 150. 逆波兰表达式求值、239. 滑动窗口最大值、347.前 K 个高频元素

150.逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

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

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation

 遍历tokens数组，使用stack存放数字，如果当前字符是运算符号，stack弹出两个元素，num2和num1，把num1和num2运算后的结果存入stack，最后返回stack的栈顶元素。

 public static int evalRPN(String[] tokens) {
        Stack<Integer>stack=new Stack<>();
        for(String token:tokens) {
        	if(!token.equals("+")&&!token.equals("-")&&!token.equals("*")&&!token.equals("/")) {
        		stack.add(Integer.parseInt(token));
        	}else {
        		int num2=stack.pop();int num1=stack.pop();
        	    int sum;
        	    if(token.equals("+")) sum=num1+num2;
        	    else if(token.equals("-")) sum=num1-num2;
        	    else if(token.equals("*")) sum=num1*num2;
        	    else sum=num1/num2;
        	    stack.push(sum);
        	}
        }
        return stack.peek();
    }

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/sliding-window-maximum

 自己创建一个队列，维护当前队列的最大值，有三个函数push(int val)，poll(int val)和getMaxval()，push元素时当val>队列的最后一个元素，队列的最后一个元素出队，直到队列为空或者队列中的元素>val；poll元素时如果当前元素等于队首元素，即要poll的元素就是当前队列的最大值时，queue.poll()；getMaxVal直接返回队列的第一个元素queue.peek();

 public int[] maxSlidingWindow(int[] nums, int k) {
         MyQueue2 queue=new MyQueue2();
    	 int []res=new int[nums.length-k+1];
         for(int i=0;i<nums.length;i++) {
        	 if(i>=k-1) {//i>=k-1，开始取最大值；i>=k,开始移除最左边的元素
        		 if(i>=k) queue.pop(nums[i-k]);
        		 queue.push(nums[i]);
        		 res[i-k+1]=queue.getMaxVal();
        	 }else {
        		 queue.push(nums[i]);
        	 }
        	 //queue.printQueue();
        	 //System.out.println(Arrays.toString(res));
         }
         return res;
    }
    public class MyQueue2 {
   //维护一个单调队列，队列出口是最大值
	Deque<Integer>deque=new ArrayDeque<Integer>();
	public MyQueue2() {
		
	}
	public void push(int val) {
		while(!deque.isEmpty()&&deque.getLast()<val) deque.removeLast();
		deque.offer(val);
	}
	public void pop(int val) {
		if(!deque.isEmpty()&&deque.peek()==val) deque.poll();
	}
	public int getMaxVal() {
		return deque.peek();
	}
	public void printQueue() {
		Iterator<Integer> it=deque.iterator();
		while(it.hasNext()) {
			System.out.print(it.next()+",");
		}
		System.out.println();
	}
}

347.前 K 个高频元素

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

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/top-k-frequent-elements

 hashmap的key记录元素，value记录元素出现过的次数，遍历hashmap，使用小顶堆维护出现频率前k高的key和value，遍历小顶堆，把堆中的数据倒序赋值给数组。

  public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer, Integer> record=new HashMap<>();
         for(int num:nums) {
        	 if(record.containsKey(num))
        	    record.put(num, record.get(num)+1);
        	 else  record.put(num,0);
         }
         PriorityQueue<int[]> queue=new PriorityQueue<>((o1,o2)-> o1[1]-o2[1]);
        for(int key:record.keySet()) {
        	queue.add(new int[] {key,record.get(key)});
        	if(queue.size()>k) queue.poll();
        }
        int[]res=new int[k];
        while(!queue.isEmpty()) {
        	res[--k]=queue.poll()[0];
        }
        return res;
    }