1、Java實現隊列（Queue）的方式

編程題目：

1.請用Java實現隊列（Queue）。

隊列實現的三種方式：

（1）通過數組實現一個隊列；

（2）通過集合實現一個對列；

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

示例代碼：

（1）通過數組實現一個隊列：

package program.stack.arrayImpl;

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

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

        //測試隊列
        System.out.println("測試隊列：");
        Queue queue = new Queue();  
        queue.in(1);  
        queue.in(2);  
        queue.in(3);  
        System.out.println(queue.out()); 
        System.out.println(queue.out()); 
        queue.in(4);  
        System.out.println(queue.out());  
        System.out.println(queue.out());  
        queue.in(5);  
        System.out.println(queue.out()); 

    }  
}  

//使用數組定義一個隊列
class Queue {  

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

    //入隊
    public void in(int m){  
       a[i++] = m;
    } 

    //出隊
    public int out(){  
       int index = 0;  
       int temp = a[1];  
       for(int j=1;j<i;j++){  
         a[j-1] = a[j];  
         index++;  
       }  
       i = index;  
       return temp;  
    }  
} 

（2）通過集合實現一個對列：

package program.stack.listImpl;

import java.util.*;

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

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

        //測試隊列
        System.out.println("測試隊列：");
        Queue queue = new Queue();  
        queue.in(1);  
        queue.in(2);  
        queue.in(3);  
        System.out.println(queue.out()); 
        System.out.println(queue.out()); 
        queue.in(4);  
        System.out.println(queue.out());  
        System.out.println(queue.out());  
        queue.in(5);  
        System.out.println(queue.out()); 

    }  
}  

//使用集合定義一個隊列
class Queue {  

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

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

    //出隊
    public int out(){  
       if(!list.isEmpty()){  
           index--;  
           return list.remove(0);  
       }  
       return -1;  
    }  

}  

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

package program.stack.twoStackImpl;

import java.util.Stack;

/**
 * 3.兩個堆棧實現一個隊列
 *  1.原理分析：
 *  隊列的主要操作有兩個：入隊操作和出隊操作，出隊時從隊頭出，入隊是從隊尾插入，
 *  入隊的操作和入棧的操作類似，而最關鍵的問題是出隊操作，要出隊列的是隊列的第一個元素，
 *  而出棧的是棧的棧頂元素，所以我們可以這樣：
 *  假設兩個棧A和棧B，A主要用來處理入隊操作，B用於處理出隊操作。入隊操作和入棧操作類似，
 *  直接將元素壓入棧即可。出隊的時候，實現我們假設棧B爲空，則要把棧A的第一個元素（即棧底元素）彈出，
 *  直接從A彈出這是不可能的，但如果我們把棧A裏面的元素的順序逆過來，這樣直接用棧彈出棧頂元素即可，
 *  所以我們可以把棧A的元素全部彈出來，並俺順序壓入棧B中，這樣每次棧B彈出的棧頂元素就是棧A相對應的棧底元素，就是出隊操作。
 *  若B不爲空，則代表之前從A複製過來的元素還沒有完全彈出，要出棧的時候直接彈出即可。若棧B的元素都彈出來了，就需要從A中補充。
 *
 *  2.總結操作就是：    
 *  入隊：將元素進棧A
 *  出隊：判斷棧B是否爲空，如果爲空，則將棧A中所有元素pop，並push進棧B，棧B出棧；如果不爲空，棧B直接出棧。
 *
 */

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

         System.out.println("3.兩個堆棧實現一個隊列：");
         Queue queue = new Queue();  
         queue.in(1);  
         queue.in(2);  
         queue.in(3);  
         System.out.println(queue.out()); 
         System.out.println(queue.out()); 
         queue.in(4);  
         System.out.println(queue.out());  
         System.out.println(queue.out());  
         queue.in(5);  
         System.out.println(queue.out()); 

    }

}

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

    Stack<Integer> stackA = new Stack<Integer>();
    Stack<Integer> stackB = new Stack<Integer>();

    //入隊
    public void in(int n) {
        stackA.push(n);
    }

    //出隊
    public int out() {
        if(stackB.isEmpty()){
            while (stackA.size() > 0) {
                stackB.push(stackA.pop());
            }
        }
        return stackB.pop();
    }

}

結果顯示：