第一题150. 逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
注意 两个整数之间的除法只保留整数部分。
可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

ψ(｀∇´)ψ 我的思路

• 题目上提示的已经很清晰了

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

package stackandqueue;

import java.util.Stack;

public class EvalRPN {

    public int evalRPN(String[] tokens) {
        int m,n;
        Stack<String> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            //如果是运算符的话，取出栈顶的两个元素，和运算符计算，结果入栈
            if(tokens[i].equals("+")){
                stack.push(String.valueOf(Integer.parseInt(stack.pop())+Integer.parseInt(stack.pop())));
            } else if (tokens[i].equals("-")) {
                m = Integer.parseInt(stack.pop());
                n = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(n-m));
            } else if (tokens[i].equals("*")) {
                stack.push(String.valueOf(Integer.parseInt(stack.pop())*Integer.parseInt(stack.pop())));
            }else if (tokens[i].equals("/")) {
                m = Integer.parseInt(stack.pop());
                n = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(n/m));
            } else {
                stack.push(tokens[i]);//如果不是运算符的话，入栈
            }
        }
        return Integer.parseInt(stack.pop());
    }
}

时间复杂度O(n)

• 在力扣上debug也太方便了吧?
  
  
  
  

第二题239. 滑动窗口最大值

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

ψ(｀∇´)ψ 我的思路

• 暴力暴力！一个for循环确定滑动窗口的位置，另一个for循环确定滑动窗口内的最大值

package stackandqueue;

public class MaxSlidingWindow {

    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length==1){
            return nums;
        }
        int[] res = new int[nums.length - k + 1];//结果数组
        for (int i = 0; i < nums.length - k + 1; i++) {
            // 确定滑动窗口的位置[i,i+k-1]
            int x = Integer.MIN_VALUE;
            for (int j = i; j < i + k; j++) {
                // 遍历滑动窗口内的值，寻找最大值
                x = nums[j] > x ? nums[j] : x;
            }
            res[i] = x;
        }
        return res;
    }
}

时间复杂度O(n^2)

• 然后就。。。超时了?

• 就很乖的去看了正经解法?

package stackandqueue;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;

public class MaxSlidingWindow2 {

    static  Deque<Integer> que = new LinkedList<>();
    public static int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length - k + 1];
        for (int i = 0; i < k; i++) {
            push(nums[i]);
        }
        res[0] = getMax();
        for (int i = 1; i < nums.length - k + 1; i++) {
            pop(nums[i-1]);//弹出元素
            push(nums[i + k-1]);//加入元素
            res[i] = getMax();//取最大值
        }
        return res;
    }
    public static void pop(int x) {
        if (!que.isEmpty() && que.peek() == x) {
            //如果队列不为空，并且队列出口的值=要弹出的值
            que.pop();
        }
    }
    public static void push(int x) {
       while (!que.isEmpty()&&x>que.getLast()){
           que.removeLast();//当队列不空且要加入的元素大于队列最后一个元素时，把最后的元素去掉（保证队列倒序）
        }
        que.addLast(x);//在把元素追加至队尾

    }
    public static int getMax() {
        // 最大值一直是队列出口的元素
        return (int) que.getFirst();
    }

    public static void main(String[] args) {
        int[] ints = maxSlidingWindow(new int[]{1,3,1,2,0,5}, 3);
        for (int i = 0; i < ints.length; i++) {
            System.out.println(ints[i]);
        }
    }
}

时间复杂度O(n)

• 尽管听了思路，实现起来还是有点复杂的，关键是push的时候要从队尾把元素移除，再加入元素，这样可以保证队列里的元素倒序。

第三题347.前 K 个高频元素

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

ψ(｀∇´)ψ 我的思路

• 这题我想着是用map，出现的次数为key，出现的元素为value，for循环一次遍历将数组存入map，对key排序，取前k个返回其value。今天不太舒服就不写了，直接看代码随想录的新方法。

package stackandqueue;

import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

public class TopKFrequent {

    public int[] topKFrequent(int[] nums, int k) {

        // 先把数组中的元素装入map
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (!map.containsKey(nums[i])) {
                map.put(nums[i], 1);
            } else {
                map.put(nums[i],map.get(nums[i])+1);
            }
        }
        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;
    }
}

• 思路听了下，但并不是很理解PriorityQueue这个东西，感觉我对队列的理解还是差点儿

总结

• 基本可以用栈来解题，但是队列我还是没有完全弄明白，大顶堆小顶堆也只是懂一点儿，先欠下来，等6号，7号的时候再做个总结。
  
  
• 今天终于做到了一道困难题，还是很开心的，期待二叉树

补充

队列

• 实现类挺多的,一般用LinkedList

堆

• 堆是一个完全二叉树
• 大顶堆：头部为堆中最大的值
• 小顶堆：头部为队中最小的值
• PriorityQueue：一个具有优先级的队列，该优先级使得队列始终按照自然顺序进行排序，队列的头部为最小值。
  

构造小顶堆：
PriorityQueue small=new PriorityQueue<>();

构造大顶堆：
PriorityQueue small=new PriorityQueue<>(Collections.reverseOrder());