Leetcode剑指Offer刷题 - 第二十七天

Leetcode剑指Offer刷题指南：

Leetcode剑指Offer刷题-学习计划目录_DEGv587的博客-CSDN博客

剑指 Offer 59 - I. 滑动窗口的最大值

解法一：暴力模拟

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 0) return new int[0];
        int len = nums.length - k + 1;
        List<Integer> list = new ArrayList<>();
        int[] ret = new int[len];
        
        for (int i = 0; i < len; ++i) {
            int max = Integer.MIN_VALUE;
            for (int j = i; j < i + k; ++j) {
                max = Math.max(nums[j], max);
            }
            list.add(max);
        }
        for (int i = 0; i < len; ++i) {
            ret[i] = list.get(i);
        }
        return ret;
    }
}

解法二：单调队列（优化版）

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 0 || k == 0) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] ret = new int[nums.length - k + 1];
        int index = 0;
        //未形成窗口区间
        for (int i = 0; i < k; ++i) {
            //队列不为空时，当前值与队列尾部值比较，如果大于，删除队列尾部值
            //一直循环删除到队列中的值都大于当前值，或者删到队列为空
            while (!deque.isEmpty() && nums[i] > deque.peekLast()) {
                deque.removeLast();
            }
            //执行完上面的循环后，队列中要么为空，要么值都比当前值大，然后就把当前值添加到队列中
            deque.addLast(nums[i]);
        }

        //窗口区间刚形成后，把队列首位值添加到队列中
        ret[index++] = deque.peekFirst();

        //窗口区间形成
        for (int i = k; i < nums.length; ++i) {
            //i-k是已经在区间外了，如果首位等于nums[i-k]，那么说明此时首位值已经不再区间内了，需要删除
            if (deque.peekFirst() == nums[i - k]) {
                deque.removeFirst();
            }
            //删除队列中比当前值小的值
            while (!deque.isEmpty() && deque.peekLast() < nums[i]) {
                deque.removeLast();
            }
            //把当前值添加到队列中
            deque.addLast(nums[i]);
            //把队列的首位值添加到arr数组中
            ret[index++] = deque.peekFirst();
        }

        return ret;
    }
}

剑指 Offer 59 - II. 队列的最大值

解法：滑动窗口（双端队列）

class MaxQueue {
    Deque<Integer> queue, deque;

    public MaxQueue() {
        //初始化队列 queue ，双向队列 deque
        queue = new LinkedList<Integer>();
        deque = new LinkedList<Integer>();
    }

    public int max_value() {
        //当双向队列 deque 为空，则返回 -1 ；
        //否则，返回 deque 首元素；
        return deque.isEmpty() ? -1 : deque.peekFirst();
    }

    public void push_back(int value) {
        //将元素 value 入队 queue ；
        queue.addLast(value);
        //将双向队列中队尾 所有 小于 value 的元素弹出（以保持 deque 非单调递减），并将元素 value 入队 deque
        while (!deque.isEmpty() && deque.peekLast() < value) {
            deque.removeLast();
        }
        deque.addLast(value);
    }

    public int pop_front() {
        //若队列 queue 为空，则直接返回 -1 ；
        if (queue.isEmpty()) return -1;
        //否则，将 queue 首元素出队；
        //若 deque 首元素和 queue 首元素 相等 ，则将 deque 首元素出队（以保持两队列 元素一致 ） ；
        if (queue.peekFirst().equals(deque.peekFirst())) {
            deque.removeFirst();
        }
        return queue.removeFirst();
    }
}