LeetCode——面试题59

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

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入:

["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]

示例 2：

输入: 
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]

限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5

https://leetcode-cn.com/problems/dui-lie-de-zui-da-zhi-lcof

两队列

c++

class MaxQueue {
    queue<int> queue;
    deque<int> maxQueue;
public:
    MaxQueue() {
    }
    
    int max_value() {
        if (maxQueue.empty())
            return -1;
        return maxQueue.front();
    }
    
    void push_back(int value) {
        while (!maxQueue.empty() && maxQueue.back() < value) {
            maxQueue.pop_back();
        }
        maxQueue.push_back(value);
        queue.push(value);
    }
    
    int pop_front() {
        if (queue.empty())
            return -1;
        int ans = queue.front();
        if (ans == maxQueue.front()) {
            maxQueue.pop_front();
        }
        queue.pop();
        return ans;
    }
};

java

public class MaxQueue {
    Queue<Integer> queue;
    Deque<Integer> maxQueue;
    public MaxQueue() {
        queue=new ArrayDeque();
        maxQueue=new ArrayDeque();
    }
    public int max_value() {
        if(maxQueue.isEmpty())
            return -1;
        return maxQueue.peek();
    }
    public void push_back(int value) {
        queue.add(value);
        while(!maxQueue.isEmpty() && value>maxQueue.getLast())
            maxQueue.pollLast();
        maxQueue.add(value);
    }
    public int pop_front() {
        if(queue.isEmpty())
            return -1;
        int ans=queue.poll();
        if(ans==maxQueue.peek())
            maxQueue.poll();
        return ans;
    }
}

python

class MaxQueue(object):

    def __init__(self):
        from collections import deque
        self.que = deque()
        self.sort_que = deque()   

    def max_value(self):
        return self.sort_que[0] if self.sort_que else -1   

    def push_back(self, value):
        self.que.append(value)
        while self.sort_que and self.sort_que[-1] < value:
            # 如果sort_que不为空，并且sort_que的最后一位元素小于当前入队元素value的话，
            # 直接把最后一位元素弹走，直到sort_que为空，或sort_que的最后一位元素大于等于value。
            # 这就保证了，sort_que的头部总是原始队列que的最大值
            self.sort_que.pop()
        self.sort_que.append(value)
        
    def pop_front(self):
        if not self.que: return -1
        ans = self.que.popleft()
        if ans == self.sort_que[0]:
            self.sort_que.popleft()
        return ans

两个数组模拟队列

java

class MaxQueue {

    int[] Queue;
    int QueueHead = 0;
    int QueueTail = 0;
    int[] MAXQueue;
    int MAXQueueHead = 0;
    int MAXQueueTail = 0;

    public MaxQueue() {
        Queue = new int[10000];
        MAXQueue = new int[10000];
    }
    
    public int max_value() {
        if(MAXQueueHead == MAXQueueTail){
            // 头尾相等的时候，表示此时队列为空，没有最大值
            return -1;
        }
        return MAXQueue[MAXQueueHead];
    }
    
    public void push_back(int value) {
        Queue[QueueTail++] = value;
        while(MAXQueueHead != MAXQueueTail && MAXQueue[MAXQueueTail-1] < value){
            // MAXQueueTail-1 因为MAXQueueTail处的值是0，还没有被初始化
            // 比value小的值，一定会在value出栈前，先出栈，
            // 队列中的最大值最少都是value，就没有保存比value小的值的必要了
            MAXQueueTail--;
        }
        MAXQueue[MAXQueueTail++] = value;
    }
    
    public int pop_front() {
        if(QueueHead == QueueTail){
            // 队列为空
            return -1;
        }
        int ans = Queue[QueueHead];
        if(ans == MAXQueue[MAXQueueHead]){
            MAXQueueHead++;
        }
        QueueHead++;
        return ans;
    }
}
        }
        int ans = Queue[QueueHead];
        if(ans == MAXQueue[MAXQueueHead]){
            MAXQueueHead++;
        }
        QueueHead++;
        return ans;
    }
}