2、Java實現堆棧（Stack）的方式

編程題目：

2.請用Java實現堆棧（Stack)。

堆棧實現的三種方式：

（1）通過數組實現一個堆棧；

（2）通過集合實現一個堆棧；

（3）通過兩個隊列實現一個堆棧。

示例代碼：

（1）通過數組實現一個堆棧：

package program.stack.arrayImpl;

/**
* 1.使用數組實現堆棧功能，使用int數組保存數據特點：先進後出，後進先出
*/

public class StackTest1 {  
    public static void main(String[] args){  

        //測試堆棧
        System.out.println("1.數組實現一個堆棧：");
        Stack stack = new Stack();  
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        stack.push(5);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());

    }  
}  

//使用數組定義一個堆棧
class Stack {  

    int[] a = new int[5];  
    int i = 0; //數組下標

    //入棧 
    public void push(int n){  
      a[++i] = n; 
    }  

    //出棧
    public int pop(){  
      if(i>0){  
         return a[i--];  
      }
      return -1;  
    }  

}  

（2）通過集合實現一個堆棧：

package program.stack.listImpl;

import java.util.*;

/**
* 2.使用集合實現堆棧功能，使用int數組保存數據特點：先進後出，後進先出
*/

public class StackTest2 {  
    public static void main(String[] args){  

        //測試堆棧
        System.out.println("2.集合實現一個堆棧：");
        Stack stack = new Stack();  
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        stack.push(5);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());

    }  
}  

//使用集合定義一個堆棧
class Stack { 

    List<Integer> list = new ArrayList<Integer>();  
    int index = 0; //下標 

    //入棧
    public void push(int n){  
        list.add(n);  
        index++;  
    } 

    //出棧
    public int pop(){  
       if(!list.isEmpty()){  
           index--;  
           return list.remove(index);  
       }  
       return -1;  
    }  
}  

（3）通過兩個隊列實現一個堆棧：

package program.stack.twoQueueImpl;

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * 3.兩個隊列實現一個堆棧
 *  1.原理分析：
 *  棧的主要操作有兩個：入棧操作和出棧操作，出棧時從棧頂出，入棧是從棧頂插入。
 *  入棧和入隊類似，都是從“所有元素後面插入”；而最關鍵的問題是出棧操作，要出棧的是的棧頂元素，
 *  而隊列每次出隊的是隊列的第一個元素。因此我們可以這樣，出隊的時候，若隊列不止一個元素，則進行出隊 操作，
 *  只保留最後一個元素，這樣出隊的時候，就符合出棧的要求了，但其他的元素必須 保留，而且順序不能亂，
 *  這時候另一個隊列就起作用了，這個隊列可以在“出棧”操作之前按順序保留所有的元素，等到“出棧”之後，
 *  把所有元素按順序進入到“出棧”後的隊列。因此兩個隊列總有一個爲空。
 *
 *  2.總結操作就是：
 *  入棧：將元素進隊列A
 *  出棧：判斷隊列A中元素的個數是否爲1，如果等於1，則出隊列，否則將隊列A中的元素  以此出隊列並放入隊列B，
 *  直到隊列A中的元素留下一個，然後隊列A出隊列，再把  隊列B中的元素出隊列以此放入隊列A中。
 *
 */

public class StackTest3 {
     public static void main(String[] args) {

         System.out.println("3.兩個隊列實現一個堆棧：");
         Stack stack = new Stack();
         stack.push(1);
         stack.push(2);
         stack.push(3);
         stack.push(4);
         System.out.println(stack.pop());
         System.out.println(stack.pop());
         stack.push(5);
         System.out.println(stack.pop());
         System.out.println(stack.pop());
         System.out.println(stack.pop());   

    }

}

//兩個隊列實現一個堆棧
class Stack {

    Queue<Integer> queueA = new ArrayDeque<Integer>();
    Queue<Integer> queueB = new ArrayDeque<Integer>();

    //入棧
    public void push(int n){
        queueA.add(n);
    }

    //出棧
    public int pop(){
        //如果queueA爲空，queueB有元素， 將queueB的元素依次放入queueA中，直到最後一個元素，我們彈出。
        if(queueA.isEmpty()){
            while (queueB.size() > 1) {
                queueA.add(queueB.poll());//poll()移出並返回隊列的頭元素,如果隊列爲空，則返回null
            }
            return queueB.poll();
        }
        if(queueB.isEmpty()){
            while (queueA.size() > 1) {
                queueB.add(queueA.poll());
            }
            return queueA.poll();
        }
        return -1;
    }

}

結果顯示：