力扣算法 150. 逆波兰表达式求值 239. 滑动窗口最大值 347. 前 K 个高频元素

学习内容

力扣算法

150. 逆波兰表达式求值

239. 滑动窗口最大值

347. 前 K 个高频元素

具体内容

150. 逆波兰表达式求值

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

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

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

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

示例 1：

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

示例 2：

输入：tokens = [“4”,“13”,“5”,“/”,“+”] 输出：6 解释：该算式转化为常见的中缀算术表达式为：(4 + (13
/ 5)) = 6

示例 3：

输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,““,”/“,””,“17”,“+”,“5”,“+”]
输出：22 解释：该算式转化为常见的中缀算术表达式为： ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

题目地址

做题思路

正常人的角度，其实是二叉树的中序遍历，但是逆波兰表达式，则是二叉树的后序遍历，即把运算符作为根节点，先把数字入栈，遇到运算符再将数字出栈，运算完后再放入栈

解题

class Solution {
	public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList();
        for (String s : tokens) {
            if ("+".equals(s)) {        // leetcode 内置jdk的问题，不能使用==判断字符串是否相等
                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 个数字。滑动窗口每次只向右移动一位。

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

示例 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]

题目地址

做题思路

此题先想到将数组里的元素全放进队列里面，之后再通过弹出第一个元素等一系列操作，实现功能。但关键的点在于！我们要弹出的元素不能是三个数字里面最大的，而我们按正常的队列则可能会将这个元素弹出，

解题

//创建一个队列 可以做到最大的值在头哥元素
class MyList{	
	Deque<Integer> deque = new LinkedList<>();
	void add(int val){
		//这里是while循环
		while(!deque.isEmpty() && val > deque.getLast()){
			deque.removeLast();
		}
		deque.add(val);
	}
	void poll(int val){
		//这里是if条件
		if(!deque.isEmpty() && val == deque.peek()){
			deque.poll();
		}
	}
	int peek() {
        return deque.peek();
    }
}
//解决
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
    	if(nums.length == 1){
    		return nums;
    	}
    	//结果集
    	int[] res = new int[nums.length-k+1];
    	//初始化
    	int num = 0;
    	MyList mylist = new MyList();
    	//这里是只存放前k个值，而不是把整个数组都放进去
    	for(int i=0;i<k;i++){
    		//现在存放的元素已经是最大的元素在前面
    		mylist.add(nums[i]);
    	}
    	res[num++] = mylist.peek();
    	//窗口依次向左移动
    	for(int i=k;i<nums.length;i++){
    		
    		//滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
            mylist.poll(nums[i - k]);
            //滑动窗口加入最后面的元素
            mylist.add(nums[i]);
            //记录对应的最大值
            res[num++] = mylist.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]

题目地址

做题思路

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。所以的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素）。解决这个问题
先用map统计出数组元素出现的个数，之后用小顶堆的思想，将小于k的数弹出，留下的元素则是大于等于k的值

解题

class Solution {
    //：基于小顶堆实现
    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]);
        小顶堆只需要维持k个元素有序
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            //小顶堆元素个数小于k个时直接加
            if(pq.size()<k){
                pq.add(new int[]{entry.getKey(),entry.getValue()});
            }else{
                //当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                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;
    }
}

解答代码存在的疑问

1、对代码中的一些方法进行解释
（1）Map提供了一些常用方法，如keySet()、entrySet()，values()等方法。
keySet()方法返回值是Map中key值的集合；
entrySet()返回值这个map中各个键值对映射关系的集合，此集合的类型为Map.Entry。
通过entrySet()方法进行获取map中的value集合：

List<实体> list = new ArrayList<>();
for (Map.Entry<Integer, List<实体>> entry:map.entrySet()){
     list.addAll(entry.getValue());
}
return list;

Map中采用Entry内部类来表示一个映射项，映射项包含Key和Value。Map.Entry里面包含getKey()和getValue()方法
（2）Map.getOrDefault(key，默认值)；
Map中会存储一一对应的key和value。
如果 在Map中存在key，则返回key所对应的的value。