剑指Offer（Java版）：用两个栈实现队列与用两个队列实现栈

2019独角兽企业重金招聘Python工程师标准>>>

题目：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数appendTail和deletedHead,分别完成在队列尾部插入节点和在队列头部删除节点的功能。

我们通过一个具体的例子来分析该队列插入和删除元素的过程。首先插入 一个元素a，不妨先把它插入到stack1，此时stack1 中的元素有｛a}，stack2为空。再压入两个元素b和c,还是插入到stack1中，此时stack1中的元素有｛a,b,c}，其中c位于栈顶，而 stack2仍然为空。

这个时候，我们试着删除从队列中删除一个元素。按照队列先入先出的规 则，由于a比b、c先插入到队列中，最先被删除的元素应该是a。元素a存储在stack1中，但并不在占顶上，因此不能直接被删除。注意到stack2我 们还一直没有使用过，现在是让stack2发挥作用的时候了。如果我们把stack1中的元素逐个弹出并压入stack2，元素在stack2中的顺序正 好和原来的stack1中的顺序相反。因此经过3次弹出stack1和压入stack2操作之后，stack1为空，而stack2中的元素是 ｛c,b,a}，这个时候就可以弹出stack2的栈顶a了。此时的stack1为空，而stack2的元素为{c,b}，其中b在栈顶，如图所示：

 

 

删除b后再插入d，d就放在stack1中，如果stack2不为空，直接弹出stack2的值，直至stack2为空，再弹出stack1的值。

Java代码实现：

package cglib;

import java.util.Stack;

public class List1<T>  
{  
    /**  
     * 用两个栈实现一个队列，完成两个函数appendTail和deletedHead,分别是在队列尾部插入节点  
     * 和在队列头部删除节点的功能   
     */  
    private Stack<T> stack1=new Stack<T>();
    private Stack<T> stack2=new Stack<T>();
    public void appendTail(T t){
        System.out.println("执行队列尾部插入节点");    
    stack1.push(t);
    System.out.println("入栈："+t);
    }
    public T deleteHead() throws Exception{
        System.out.println("执行队列头部删除节点");
         T t=null;
        if(!stack2.empty()){  
             t=stack2.pop();
             System.out.println("stack2不为空，出栈："+t);
        }
        else{
            System.out.println("stack2为空");
            while(!stack1.empty()){
                t=stack1.pop();
                System.out.println("stack2为空，stack1不为空，stack1出栈："+t);
                stack2.push(t);  
                System.out.println("然后stack2入栈："+t);
            }  
            if(!stack2.empty()){  
                t=stack2.pop();
                System.out.println("stack2不为空，stack2出栈，相当于执行队列头部删除节点："+t);
            }  
        }  
        return t;
        
    }
    public static void main(String args[]) throws Exception
    {
        List1<String> p7=new List1<>();
    p7.appendTail(null);
    p7.appendTail("2");
    p7.appendTail("3");
    p7.deleteHead();
    p7.deleteHead();
    p7.appendTail("4");
    p7.appendTail("5");
    p7.deleteHead();
    p7.deleteHead();
    p7.deleteHead();
    p7.deleteHead();
}
}

 

输出：

执行队列尾部插入节点
入栈：null
执行队列尾部插入节点
入栈：2
执行队列尾部插入节点
入栈：3
执行队列头部删除节点
stack2为空
stack2为空，stack1不为空，stack1出栈：3
然后stack2入栈：3
stack2为空，stack1不为空，stack1出栈：2
然后stack2入栈：2
stack2为空，stack1不为空，stack1出栈：null
然后stack2入栈：null
stack2不为空，stack2出栈，相当于执行队列头部删除节点：null
执行队列头部删除节点
stack2不为空，出栈：2
执行队列尾部插入节点
入栈：4
执行队列尾部插入节点
入栈：5
执行队列头部删除节点
stack2不为空，出栈：3
执行队列头部删除节点
stack2为空
stack2为空，stack1不为空，stack1出栈：5
然后stack2入栈：5
stack2为空，stack1不为空，stack1出栈：4
然后stack2入栈：4
stack2不为空，stack2出栈，相当于执行队列头部删除节点：4
执行队列头部删除节点
stack2不为空，出栈：5
执行队列头部删除节点
stack2为空

用两个队列实现栈。

通过一系列的栈的压入和弹出操作来分析用队列模拟一个栈的过程，如图所示，我们先往栈内压入一个元素a。由于两个队列现在都是空，我们可以选择把a 插入两个队列中的任一个。我们不妨把a插入queue1。接下来继续网栈内压入b,c两个元素。我们把它们都插入queue1。这个时候 queue1包含3个元素a,b,c其中a位于队列的头部，c位于队列的尾部。

现在我们考虑从栈内弹出一个元素。根据栈的后入先出的原则，最后被压 入栈的c应该最先被弹出。由于c位于queue1的尾部，而我们每次只能从队列的头部删除元素，因此我们可以从queueu中依次删除a/b/c并插入到 queue2中，再从queue1中删除c。这就相当于从栈中弹出元素c了。我们可以用同样的方法从栈内弹出元素b。

接下来我们考虑从栈内压入一个元素d.此时queue1已经有了一个 元素，我们就把d插入到queue1的尾部。如果我们再从栈内弹出一个元素，此时被弹出的应该是最后被压入的d.由于d位于queue1的尾部，我们只能 先从头部删除 queue1的元素并插入到queue2，直到queue1中遇到d再直接把它删除。如图所示：

Java代码实现：

package cglib;

import java.util.LinkedList;

public class List1<T>  
{  
    private LinkedList<T> queue1= new LinkedList<T>();  
    private LinkedList<T> queue2= new LinkedList<T>();  
      
    public List1(){  
         
    }  
      
    public T pop(){  
        T re =null;  
        if(queue1.size() == 0 && queue2.size() == 0){
            System.out.println("队列空了");
            return null;  
        }  
        if(queue2.size() == 0){
            System.out.println("队列2空");
            while(queue1.size() >0){
                System.out.println("队列1不空");
                re = queue1.removeFirst();
                System.out.println("队列1除去："+re);
                if(queue1.size() != 0){  
                    queue2.addLast(re);
                    System.out.println("队列2加进："+re);
                }  
            }  
        }else if(queue1.size() == 0){
            System.out.println("队列1空");
            while(queue2.size() >0){  
                System.out.println("队列2不空");
                re = queue2.removeFirst();
                System.out.println("队列2除去："+re);
                if(queue2.size()!=0){  
                    queue1.addLast(re);
                    System.out.println("队列1加进："+re);
                }  
            }  
        }  
        return re;  
    }  
    public T push(T str){  
        if(queue1.size() ==0 && queue2.size() == 0){  
            queue1.addLast(str);
            System.out.println("两个队列都为空，队列1加进："+str);
        }  
        if(queue1.size()!=0){  
            queue1.addLast(str);
            System.out.println("队列1不为空，队列1加进："+str);
        }else if(queue2.size()!=0){  
            queue2.addLast(str);
            System.out.println("队列2不为空，队列2加进："+str);
        }  
        return str;  
    }  
      
     public static void main(String[] args) {    
         List1<String> stack=new List1<>();    
            String tmp;    
            stack.push("1");    
            stack.push("2");    
            stack.push("3");    
            tmp=stack.pop();    
            System.out.println("出栈："+tmp);//3    
            stack.push("4");    
            tmp=stack.pop();    
            System.out.println("出栈："+tmp);//4    
            tmp=stack.pop();    
            System.out.println("出栈："+tmp);//2    
            stack.push("5");    
            stack.push("6");    
            tmp=stack.pop();    
            System.out.println("出栈："+tmp);//6    
            tmp=stack.pop();    
            System.out.println("出栈："+tmp);//5    
            tmp=stack.pop();    
            System.out.println("出栈："+tmp);//1    
     }   
}

 

输出：

两个队列都为空，队列1加进：1
队列1不为空，队列1加进：1
队列1不为空，队列1加进：2
队列1不为空，队列1加进：3
队列2空
队列1不空
队列1除去：1
队列2加进：1
队列1不空
队列1除去：1
队列2加进：1
队列1不空
队列1除去：2
队列2加进：2
队列1不空
队列1除去：3
出栈：3
队列2不为空，队列2加进：4
队列1空
队列2不空
队列2除去：1
队列1加进：1
队列2不空
队列2除去：1
队列1加进：1
队列2不空
队列2除去：2
队列1加进：2
队列2不空
队列2除去：4
出栈：4
队列2空
队列1不空
队列1除去：1
队列2加进：1
队列1不空
队列1除去：1
队列2加进：1
队列1不空
队列1除去：2
出栈：2
队列2不为空，队列2加进：5
队列2不为空，队列2加进：6
队列1空
队列2不空
队列2除去：1
队列1加进：1
队列2不空
队列2除去：1
队列1加进：1
队列2不空
队列2除去：5
队列1加进：5
队列2不空
队列2除去：6
出栈：6
队列2空
队列1不空
队列1除去：1
队列2加进：1
队列1不空
队列1除去：1
队列2加进：1
队列1不空
队列1除去：5
出栈：5
队列1空
队列2不空
队列2除去：1
队列1加进：1
队列2不空
队列2除去：1
出栈：1

 

转载于:https://my.oschina.net/u/2822116/blog/713054