【剑指Offer】队列的最大值&栈的最小值

队列的最大值

dataQueue作为主队列，负责元素出队列和入队列，maxQueue的队头始终是主队列中的元素最大值。

当入队列的元素大于 maxQueue的队尾时，将maxQueue队尾元素依次弹出，直到遇到大于入队元素的值。如果入队元素比maxQueue队尾元素小，则直接加入maxQueue。

这里的弹出和主队列是无关的，因为这些较小的值在主队列中会先于较大的值出队列，所以主队列中的最大值，始终是maxQueue的队头元素。

在主队列元素出队列的时候，比较出队元素和maxQueue的队头是否相等，相等则maxQueue队头一起出队列。

【这个的思路和生成窗口的最大数组是差不多的】

class MaxQueue {
    private LinkedList<Integer> dataQueue;
    private LinkedList<Integer> maxQueue;
    public MaxQueue() {
        this.dataQueue = new LinkedList<>();
        this.maxQueue = new LinkedList<>();
    }
    
    public int max_value() {
        if(maxQueue.isEmpty()){
            return -1;
        }
        return maxQueue.peek();
    }
    
    public void push_back(int value) {
        dataQueue.offer(value);
        while(!maxQueue.isEmpty() && value > maxQueue.peekLast()){
            maxQueue.pollLast();
        }
        maxQueue.offer(value);
    }
    
    public int pop_front() {
        if(dataQueue.isEmpty()){
            return -1;
        }
        int x = dataQueue.pop();
        if(x == maxQueue.peek()){
            maxQueue.pop();
        }
        return x;
    }
}

栈的最小值

public class MinStack {
    private Stack<Integer> minStack;
    private Stack<Integer> dataStack;
    public MinStack() {
        this.minStack = new Stack<>();
        this.dataStack = new Stack<>();
    }

    public void push(int x) {
        dataStack.push(x);
        if(x <= minStack.peek()){
            minStack.push(x);
        }
    }

    public void pop() {
        int x = dataStack.pop();
        if(x == minStack.peek()){
            minStack.pop();
        }
    }

    public int top() {
        LinkedList<Integer> a = new LinkedList<>();26         return dataStack.peek();

    }

    public int min() {
        return minStack.peek();
    }
}