栈与队列

347. Top K Frequent Elements

class Solution {
    //比较器
    Comparator cmp = new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            Map.Entry<Integer, Integer> e1 = (Map.Entry<Integer, Integer>) o1;
            Map.Entry<Integer, Integer> e2 = (Map.Entry<Integer, Integer>) o2;
            return e1.getValue() - e2.getValue();
        }
    };
    public int[] topKFrequent(int[] nums, int k) {
        int len = nums.length;
        if (len <= 1) return nums;
        Map<Integer, Integer> map = new HashMap<>();
        int[] res = new int[k];


        for (int i : nums) {
            map.put(i, map.getOrDefault(i, 0) + 1);
        }



        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        //小顶堆，使用比较器
        //PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>(cmp);
        //小顶堆  使用lambda表达式，匿名函数
        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>(
            (e1, e2) -> e1.getValue() - e2.getValue());
        for (Map.Entry<Integer, Integer> ei : entries) {
            queue.offer(ei);
            if (queue.size() > k) {
                queue.poll();
            }
        }



        for (int i = k - 1; i >= 0; i--) {
            res[i] = queue.poll().getKey();
        }
        return res;



    }
}

 

 

 

239. Sliding Window Maximum

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        MQueue mqueue = new MQueue();
        int len = nums.length, p = 0;
        int[] a = new int[len - k + 1];
        if (len == 1) {
            return nums;
        }
        int i = 0;
        //放入滑动窗口
        while (i < k) {
            mqueue.offer(nums[i]);
            i++;
        }
        for (; i < len; i++) {
            //存入当前滑动窗口最大值
            a[p++] = mqueue.peek();
            //向右滑动一格
            mqueue.poll(nums[i - k]);
            mqueue.offer(nums[i]);
        }
        //最后的窗口
        a[p++] = mqueue.peek();
        return a;
    }
    
}
//单调队列
class MQueue {
    private Deque<Integer> deque  = new LinkedList();
    //只维护可能成为最大值的值
    void offer(int val) {
        while (!deque.isEmpty() && deque.peekLast() < val) {
            deque.removeLast();
        }
        deque.offer(val);
    }

    //挤出的窗口的值为max，弹出单调队列
    void poll(int val) {
        if (!deque.isEmpty() && deque.peek() == val) {
            deque.poll();
        }
    }

    int peek() {
        return deque.peek();
    }
}

 

知识点：单调队列、优先级队列和lambda表达式。

参考：代码随想录：programmercarl.com