剑指offer之面试题59：队列的最大值

面试题59：队列的最大值

题目1：滑动窗口的最大值
给定一个数组和滑动窗口的大小，请找出所有滑动窗口里的最大值。例如，如果如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}。

思路1：暴力解法

代码实现：

package Question59;

import java.util.Arrays;

public class T01 {
    public static void main(String[] args) {
        int[] arr = {2,3,4,2,6,2,5,1};
        int n = 3;
        System.out.println(Arrays.toString(solve(arr, n)));
    }

    public static int[] solve(int[] arr, int n) {
        if(arr == null || arr.length == 0) return new int[0];
        int[] result = new int[arr.length-n+1];
        for(int i = 0; i < result.length; i++) {
            result[i] = getMax(arr, i, i+n-1);
        }
        return result;
    }

    public static int getMax(int[] arr, int left, int right) {
        int max = arr[left];
        for(int i = left + 1; i <= right; i++) {
            max = arr[i] > max ? arr[i] : max;
        }
        return max;
    }
}

思路2：

• 可以用两个栈来模拟队列。即一个作为主栈，一个作为辅助栈。元素一般都存放在主栈，只有在出栈时才把主栈的元素全部都压入辅助栈，然后从辅助栈中出栈一个元素，再将辅助栈中的元素全部都压入主栈
• 可以用一个数组来记录主栈中元素的最大值。
• 将以上两种方法结合就可以用来解决此题。

代码实现：

package Question59;

import java.util.Arrays;

public class T02 {
    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 2, 6, 2, 5, 1};
        int n = 4;
        System.out.println(Arrays.toString(solve(arr, n)));
    }

    public static int[] solve(int[] arr, int n) {
        if(arr == null || arr.length < n) return new int[0];
        MyStack myStack = new MyStack(n);
        int[] result = new int[arr.length - n + 1];
        int i = 0;
        while(i < n - 1) myStack.push(arr[i++]);
        for(; i < arr.length; i++) {
            myStack.push(arr[i]);
            result[i-n+1] = myStack.getMax();
            myStack.pop();
        }
        return result;
    }
}

class MyStack {
    int[] arr1;
    int[] arr2;
    int[] tempMax;
    int top1 = -1;
    int top2 = -1;

    public MyStack(int n) {
        arr1 = new int[n];
        arr2 = new int[n];
        tempMax = new int[n];
    }

    public boolean isFull() {
        return top1 == arr1.length - 1;
    }

    public boolean isEmpty() {
        return top1 == -1;
    }

    public void push(int x) {
        if(isFull()) {
            throw new RuntimeException("栈已满，无法装入");
        }
        if(top1 >= 0) {
            arr1[++top1] = x;
            tempMax[top1] = x > tempMax[top1-1] ? x : tempMax[top1-1];
        } else {
            arr1[++top1] = x;
            tempMax[top1] = x;
        }
    }

    public int pop() {
        if(isEmpty()) {
            throw new RuntimeException("栈是空的，无法弹出");
        }
        while(top1 >= 0) arr2[++top2] = arr1[top1--];
        int result = arr2[top2--];
        while(top2 >= 0) push(arr2[top2--]);
        return result;
    }

    public int getMax() {
        if(top1 == -1) throw new RuntimeException("栈空，无法获取最大值");
        return tempMax[top1];
    }
}

思路3：双端队列

• 以{2,3,4,2,6,2,5,1}为例，2直接进入双端队列。
• 3, 因为比队头元素大，所以队内元素全部出队，3入队
• 4, 因为比队头元素大，所以队内元素全部出队，4入队
• 2，因为比队头元素小，但是有可能成为4之后的最大元素，所以2入队
• 6，因为比队头元素大，所以队内元素全部出队，6入队
• 2，比队头元素小，但是有可能成为6之后最大的元素，所以2入队
• 5，比队头元素小，但比队尾元素大，所以2出队，5入队
• 1，因为这个时候6已经在窗口外了，所以6出队，此时1有可能成为5之后最大的元素，所以1入队。
• 直接操作数据比较麻烦，所以队列中存入数据在数组中的索引。

代码实现：

package Question59;

import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedList;

public class T03 {
    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 2, 6, 2, 5, 1};
        System.out.println(Arrays.toString(solve(arr, 3)));
    }

    public static int[] solve(int[] arr, int n) {
        if(arr == null || arr.length == 0 ||arr.length < n) return new int[0];
        Deque<Integer> deque = new LinkedList<>();
        int[] result = new int[arr.length-n+1];
        for(int i = 0; i < arr.length; i++) {
            while(!deque.isEmpty() && arr[i] > arr[deque.getLast()]) deque.removeLast();
            while(!deque.isEmpty() && i - deque.getFirst() >= n) deque.removeFirst();
            deque.addLast(i);
            if(i >= n-1) result[i-n+1] = arr[deque.getFirst()];
        }
        return result;
    }
}

题目二：队列的最大值
请定义一个队列并实现函数max得到队列里的最大值，要求函数max、push_back和pop_front的时间复杂度都是O(1)。

思路：跟题目一类似，这个时候把窗口变为整个队列的长度即可。

代码实现：

class MaxQueue {
    Queue<Integer> queue;
    Deque<Integer> deque;

    public MaxQueue() {
        queue = new LinkedList<Integer>();
        deque = new LinkedList<Integer>();
    }

    public int max_value() {
        if(queue.isEmpty()) return -1;
        else return deque.peek();
    }

    public void push_back(int value) {
        queue.offer(value);
        while(!deque.isEmpty() && value > deque.getLast()) deque.removeLast();
        deque.addLast(value);
    }

    public int pop_front() {
        if(queue.isEmpty()) return -1;
        int result = queue.poll();
        if(result == deque.peek()) deque.removeFirst();
        return result;
    }
}