劍指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