001什么是隊列？

隊列是一種先進先出的數(shù)據(jù)結(jié)構(gòu)，這和棧有所不同，但又更容易理解。類似于食堂排隊打飯，車站排隊買票。后來的人排在隊伍最后邊，先來的人先打飯或者買票走。

隊列：只允許在一端進行插入數(shù)據(jù)操作，在另一端進行刪除數(shù)據(jù)操作的特殊線性表，進行插入操作的一端稱為隊尾 出隊列：進行刪除操作的一端稱為隊頭

002一個隊列的進隊順序是1,2，....n，若進隊和出隊可以交替進行，則出隊順序可能是( )。

A. 1,2,........,n
B. 1,2,4,3,5,6,.....,n
C. n,n-1,....,1
D. 以上均有可能
答案：A
解析：隊列是先進先出，所以B選項中3比4先入隊，所以3比4先出隊；C選項同理。

003隊列的“先進先出”特性是指( )。

A. 最早插入隊列中的元素總是最后被刪除
B. 當同時進行插入、刪除操作時，總是插入操作優(yōu)先
C. 每當有刪除操作時，總是要先做一次插入操作
D. 每次從隊列中刪除的總是最早插入的元素
答案：D
解析：A選項中隊列中的元素不一定非得刪除；
B選項中，插入和刪除的操作看誰先執(zhí)行就就優(yōu)先操作；
C選項中，刪除操作時和插入沒有關(guān)系；

004循環(huán)隊列的出隊操作為（）。

A.sq.front=(sq.front+1)% maxsize；
B.sq.front=sq.front+1；
C.sq.rear=(sq.rear+1)% maxsize；
D.sq.rear=sq.rear+1；
答案：A
解析：考察的是循環(huán)隊列的特性和定義以及操作。 循環(huán)隊列：最后一個單元的后繼是第一個單元的隊列。

005隊列是一種運算受限的線性表，以下說法準確的是？

A.單向隊列在允許刪除的一端叫隊頭，在允許插入的一端叫隊尾。
B.單向隊列在允許刪除的一端叫隊尾，在允許插入的一端叫隊頭。
C.隊列可以用數(shù)組實現(xiàn)，也可以用鏈表實現(xiàn)
D.隊列是先進先出的，棧是后進先出的
正確答案：ACD
解析：暫無解析

006下述有關(guān)棧和隊列的區(qū)別，說法錯誤的是？

A.棧是限定只能在表的一端進行插入和刪除操作。
B.隊列是限定只能在表的一端進行插入和在另一端進行刪除操作。
C.棧和隊列都屬于線性表
D.棧的插入操作時間復雜度都是o(1)，隊列的插入操作時間復雜度是o(n)
正確答案：D
解析：暫無解析

007數(shù)組實現(xiàn)隊列？

隊列本身是有序列表，若使用數(shù)組的結(jié)構(gòu)來存儲隊列的數(shù)據(jù)，則隊列數(shù)組的聲明如下圖 , 其中 maxSize 是該隊列的最大容量。
因為隊列的輸出、輸入是分別從前后端來處理，因此需要兩個變量 front 及 rear 分別記錄隊列前后端的下標，front 會隨著數(shù)據(jù)輸出而改變，而 rear 則是隨著數(shù)據(jù)輸入而改變，如圖所示

當我們將數(shù)據(jù)存入隊列時稱為” addQueue ”， addQueue 的處理需要有兩個步驟：思路分析
1)將尾指針往后移： rear+1 , 當 front == rear 【空】
2)若尾指針 rear 小于隊列的最大下標 maxSize-1 ，則將數(shù)據(jù)存入 rear 所指的數(shù)組元素中，否則無法存入數(shù)據(jù)。rear == maxSize - 1[ 隊列滿 ]

008數(shù)組實現(xiàn)隊列的代碼實現(xiàn)。

import java.util.Scanner;
public class ArrayQueueDemo {
    public static void main(String[] args) {
        //測試一把
        // 創(chuàng)建一個隊列
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' '; //接收用戶輸入
        Scanner scanner = new Scanner(System.in); //
        boolean loop = true;
        //輸出一個菜單
        while (loop) {
            System.out.println("s(show): 顯示隊列");
            System.out.println("e(exit): 退出程序");
            System.out.println("a(add): 添加數(shù)據(jù)到隊列");
            System.out.println("g(get): 從隊列取出數(shù)據(jù)");
            System.out.println("h(head): 查看隊列頭的數(shù)據(jù)");
            key = scanner.next().charAt(0); //接收一個字符
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("輸出一個數(shù)");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g': //取出數(shù)據(jù)
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的數(shù)據(jù)是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h': //查看隊列頭的數(shù)據(jù)
                    try {
                        int res = queue.headQueue();
                        System.out.printf("隊列頭的數(shù)據(jù)是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e': //退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出~~");
    }
}
class ArrayQueue {
    private int maxSize; //表示數(shù)組的最大容量
    private int front; //表示隊列頭
    private int rear; //表示隊列尾
    private int[] arr; //該數(shù)組用于存放數(shù)據(jù)，模擬隊列

    //創(chuàng)建隊列的構(gòu)造器
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1; // 指向隊列頭部前一個位置
        rear = -1; // 指向隊列尾，指向隊列尾的數(shù)據(jù)(即就是隊列最后一個數(shù)據(jù))
    }

   //判斷隊列是否滿
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    // 判斷隊列是否為空
    public boolean isEmpty() {
        return rear == front;
    }

    // 添加數(shù)據(jù)到隊列
    public void addQueue(int n) {
        // 判斷隊列是否滿
        if (isFull()) {
            System.out.println("隊列滿，不能加入數(shù)據(jù)~");
            return;
        }

        rear++; // 讓 rear 后移
        arr[rear] = n;
    }

    // 獲取隊列的數(shù)據(jù), 出隊列
    public int getQueue() {
        // 判斷隊列是否空
        if (isEmpty()) {
            // 通過拋出異常
            throw new RuntimeException("隊列空，不能取數(shù)據(jù)");
        }
        front++; // front 后移
        return arr[front];
    }

    // 顯示隊列的所有數(shù)據(jù)
    public void showQueue() {
        // 遍歷
        if (isEmpty()) {
            System.out.println("隊列空的，沒有數(shù)據(jù)~~");
            return;
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    // 顯示隊列的頭數(shù)據(jù)， 注意不是取出數(shù)據(jù)
    public int headQueue() {
        // 判斷
        if (isEmpty()) {
            throw new RuntimeException("隊列空的，沒有數(shù)據(jù)~~");
        }
        return arr[front + 1];
    }
}