标签：class   元素   ==   OLE   ring   size   pop   用两个   lang   

分析

使用两个栈，一个主(s1)，一个辅(s2)
我们并不需要真正实现类似队列的结构，只需要实现队列的功能即可：
push:直接push到s1即可，这时和队列的性质相反(FIFO vs. LIFO)
pop:目标是拿到队头，即栈底，只需要把除栈底外的元素移动到辅助栈s2，然后弹出栈底，最后把s2元素再移回来
peek：和pop类似，不要弹出s1栈底即可。

分析清楚了实现也就不难了。

实现：

public class TwoStackAsQueue {
    private Stack<Integer> s1 ;
    private Stack<Integer> s2 ;

    public TwoStackAsQueue(){
        s1 = new Stack<>();//主
        s2 = new Stack<>();//辅
    }

    /*
    push的时候：直接push到s1
     */
    public void push(int a){
        s1.push(a);
    }

    //把除栈底外全部移到另一个栈，移除栈底，在把元素移回来
    public boolean pop(){
        if (s1.size()==0){
            System.out.println("Empty");
            return false;
        }
        while (s1.size()!=1){
            s2.push(s1.pop());
        }
        s1.pop();
        while (s2.size()!=0){
            s1.push(s2.pop());
        }
        return true;
    }


    public int peek(){
        if (s1.size()==0){
            System.out.println("Empty");
            return -1;
        }
        while (s1.size()!=1){
            s2.push(s1.pop());
        }
        int res =  s1.peek();
        while (s2.size()!=0){
            s1.push(s2.pop());
        }
        return res;
    }

    public int size(){
        return s1.size();
    }

    public static void main(String[] args) {
        TwoStackAsQueue tsa = new TwoStackAsQueue();
        tsa.push(1);
        tsa.push(2);
        tsa.push(3);
        System.out.println(tsa.size());
        System.out.println(tsa.peek());
        tsa.pop();
        tsa.pop();
        System.out.println(tsa.size());
        System.out.println(tsa.peek());
        /*
        output:
            3
            1
            1
            3
         */
    }
}

两个栈实现一个队列

标签：class   元素   ==   OLE   ring   size   pop   用两个   lang   

原文地址：https://www.cnblogs.com/XT-xutao/p/12788781.html