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

题目：用两个栈实现一个队列。队列的声明以下，请实现它的两个函数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