LinkedList

接口里有Queue和Deque

• Queue 队列，先进先出
• Deque (double ended queue) 双端队列

Queue {
	boolean add(E e); // 入队
	boolean offer(E e); //入队，和add一样
	E poll(); //出队
	E peek(); //队首
}

队列经常和栈一起

class Stack{
    public E push(E item) {} //压入栈顶
    public synchronized E pop() {} //出栈
    public synchronized E peek() {} //查栈顶元素
}

Deque 的加入使得LinkedList也拥有了Stack的功能

    void addFirst(E e);
    boolean offerFirst(E e);  
    boolean offerLast(E e);    
    E removeFirst();   
    E removeLast();   
    E pollFirst();    
    E pollLast();   
    E getFirst();    
    E getLast();   
    E peekFirst();    
    E peekLast();
    boolean offer(E e);
    E poll();
    
    //以下为栈的方法
    E peek();
    void push(E e);
    E pop();

算法题

队列的最大值

请定义一个队列并实现函数 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]

Java实现：

具体的实现动画观看

class MaxQueue {
    // LinkedList 可以看成为是一个双端队列
    private LinkedList<Integer> queue=null;
    private LinkedList<Integer> sorted_queue=null;
    public MaxQueue() {
        this.queue=new LinkedList();
        this.sorted_queue=new LinkedList(); 
    }
    
    public int max_value() {
        return this.sorted_queue.isEmpty()?-1:this.sorted_queue.peekLast();
    }
    
    public void push_back(int value) {
        this.queue.offer(value);
         //这里将sorted_queue当作栈来使用
        while(!this.sorted_queue.isEmpty() && this.sorted_queue.peek()<value)
              this.sorted_queue.pop();
         this.sorted_queue.push(value);
        
    }
    
    public int pop_front() {
        if(this.queue.isEmpty())
         return -1;
        int res=this.queue.poll();
        //sorted_queue 如果单纯是 stack的话是没法获取到栈底元素
        //所以使用了deque后就可以用peekLast和removeLast来查看和移除栈底元素
        if(res==this.sorted_queue.peekLast()){
            this.sorted_queue.removeLast();
        }
        return res;
    }
}

python 里也有deque ( from collections import deque)
python的实现，做个比对

class MaxQueue:

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

    def max_value(self) -> int:
        return self.sorted_que[0] if self.sorted_que else -1


    def push_back(self, value: int) -> None:
        while self.sorted_que and self.sorted_que[-1]<value:
            self.sorted_que.pop()
        self.sorted_que.append(value)    

    def pop_front(self) -> int:
        if self.que:
            n=self.que.pop()
            if n==self.sorted_que[0]:
             self.sorted_que.popLeft() 
            return n
        else:
            return -1

和该题类似的有：
求Stack的 maxValue() 方法来实现栈的最大值，要求也是O(1)的时间复杂度。