单调队列解题记录

剑指offer-59 滑动窗口的最大值

元素从左边移除，右边加入，可以用队列解决
不断维护一个单调递减的队列，两个点：
1）新加元素跟队尾元素比较，队尾元素小于当前值，就不断弹出，直到队列为空，或者队尾元素大于当前值
2）当前值的下标和队首元素下标大于k，则弹出队首元素，保证窗口的大小不超标

public class SlideWindow_59 {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 0){
            return new int[0];
        }
        //单调队列
        LinkedList<Integer> stack = new LinkedList<>();
        int[] res = new int[nums.length - k + 1];
        for (int i = 0, j = 0; i < nums.length; i++){
            //如果窗口内超过k个数，则去掉队首的元素
            if (!stack.isEmpty() && i - stack.getFirst() >= k){
                stack.removeFirst();
            }
            //维护队列递减：判断当前元素是否大于队尾，大于需一直弹出队尾
            while(!stack.isEmpty() && nums[stack.getLast()] <= nums[i]){
                stack.removeLast();
            }
            //队尾添加最新的元素
            stack.addLast(i);

            if (i >= k-1){
                res[j++] = nums[stack.getFirst()];
            }
        }
        return res;

//暴力法
//        int left = 0;
//        int right = left + k - 1;
//        int[] res = new int[nums.length - k + 1];
//        int index = 0;
//        while(right < nums.length){
//            res[index++] = finaMax(nums, left, right);
//            left++;
//            right++;
//        }
//        return res;
//
//    }
//    public static int finaMax(int[] nums, int left, int right){
//        if (left == right){return nums[left];}
//        int res= Integer.MIN_VALUE;
//        for (int i = left; i <= right; i++){
//            res = Math.max(res, nums[i]);
//        }
//        return res;
    }
}

剑指offer 59-2 队列的最大值

使用一个辅助队列，将这个队列维护为单调递减队列

public class MaxQueue_59_2 {
    public LinkedList<Integer> queue;  //原始队列
    public LinkedList<Integer> helper; //单调队列
    public MaxQueue_59_2() {
        queue = new LinkedList<>();
        helper = new LinkedList<>();

    }

    public int max_value() {
        if (! queue.isEmpty()){
            return helper.getFirst();
        }else{
            return -1;
        }
    }

    public void push_back(int value) {
        queue.addLast(value);
        while(!helper.isEmpty() && helper.getLast() <= value){
            helper.removeLast();
        }
        helper.addLast(value);
    }

    public int pop_front() {
    //注意辅助队列的队首元素和原始队列的队首一致，都要弹出
        if (!queue.isEmpty()){
            int val = queue.removeFirst();
            if (helper.getFirst() == val){
                helper.removeFirst();
            }
            return val;
        }else{
            return -1;
        }
    }
}