佇列介紹

-》佇列是一個有序列表，可以用陣列或是連結串列來實現。

-》遵循先入先出的原則。即：先存入佇列的資料，要先取出，後存入的要後取出

-》示意圖：（使用是陣列模擬佇列示意圖）

-》其中maxsSize是該佇列的最大容量。

-》因為佇列的輸出、輸入分別是從前後端來處理，因此需要兩個變數front及rear分別記錄佇列前後端的下標，front會隨著陣列輸出而改變，而rear則是隨著資料輸入而改變。

-》當我們將資料存入佇列時稱為“addQueue”,addQueue的處理需要有兩個步驟：思路分析

（1）將尾指標往後移：rear+1, 當front==rear【空】

（2）若尾指標rear小於佇列的最大下表maxSize-1,則將資料存入rear所指的陣列元素中，否則無法存入資料。

　rear==maxSize-1【佇列滿】

-》程式碼實現

  1 package com.atguigu.queue;
  2 
  3 import java.util.Scanner;
  4 
  5 public class ArrayQueueDemo {
  6 
  7     public static void main(String[] args) {
  8         //測試一把
  9         //建立一個佇列
 10         ArrayQueue queue = new
 
 ArrayQueue(3);
 11         char key = ' '; //接收使用者輸入
 12         Scanner scanner = new Scanner(System.in);//
 13         boolean loop = true;
 14         //輸出一個選單
 15         while(loop) {
 16             System.out.println("s(show): 顯示佇列");
 17             System.out.println("e(exit): 退出程式");
 18             System.out.println("a(add): 新增資料到佇列");
 
 19             System.out.println("g(get): 從佇列取出資料");
 20             System.out.println("h(head): 檢視佇列頭的資料");
 21             key = scanner.next().charAt(0);//接收一個字元
 22             switch (key) {
 23             case 's':
 24                 queue.showQueue();
 25                 break;
 26             case 'a':
 27                 System.out.println("輸出一個數");
 28                 int value = scanner.nextInt();
 29                 queue.addQueue(value);
 30                 break;
 31             case 'g': //取出資料
 32                 try {
 33                     int res = queue.getQueue();
 34                     System.out.printf("取出的資料是%d\n", res);
 35                 } catch (Exception e) {
 36                     // TODO: handle exception
 37                     System.out.println(e.getMessage());
 38                 }
 39                 break;
 40             case 'h': //檢視佇列頭的資料
 41                 try {
 42                     int res = queue.headQueue();
 43                     System.out.printf("佇列頭的資料是%d\n", res);
 44                 } catch (Exception e) {
 45                     // TODO: handle exception
 46                     System.out.println(e.getMessage());
 47                 }
 48                 break;
 49             case 'e': //退出
 50                 scanner.close();
 51                 loop = false;
 52                 break;
 53             default:
 54                 break;
 55             }
 56         }
 57         
 58         System.out.println("程式退出~~");
 59     }
 60 
 61 }
 62 
 63 // 使用陣列模擬佇列-編寫一個ArrayQueue類
 64 class ArrayQueue {
 65     private int maxSize; // 表示陣列的最大容量
 66     private int front; // 佇列頭
 67     private int rear; // 佇列尾
 68     private int[] arr; // 該資料用於存放資料, 模擬佇列
 69 
 70     // 建立佇列的構造器
 71     public ArrayQueue(int arrMaxSize) {
 72         maxSize = arrMaxSize;
 73         arr = new int[maxSize];
 74         front = -1; // 指向佇列頭部，分析出front是指向佇列頭的前一個位置.
 75         rear = -1; // 指向佇列尾，指向佇列尾的資料(即就是佇列最後一個數據)
 76     }
 77 
 78     // 判斷佇列是否滿
 79     public boolean isFull() {
 80         return rear == maxSize - 1;
 81     }
 82 
 83     // 判斷佇列是否為空
 84     public boolean isEmpty() {
 85         return rear == front;
 86     }
 87 
 88     // 新增資料到佇列
 89     public void addQueue(int n) {
 90         // 判斷佇列是否滿
 91         if (isFull()) {
 92             System.out.println("佇列滿，不能加入資料~");
 93             return;
 94         }
 95         rear++; // 讓rear 後移
 96         arr[rear] = n;
 97     }
 98 
 99     // 獲取佇列的資料, 出佇列
100     public int getQueue() {
101         // 判斷佇列是否空
102         if (isEmpty()) {
103             // 通過丟擲異常
104             throw new RuntimeException("佇列空，不能取資料");
105         }
106         front++; // front後移
107         return arr[front];
108 
109     }
110 
111     // 顯示佇列的所有資料
112     public void showQueue() {
113         // 遍歷
114         if (isEmpty()) {
115             System.out.println("佇列空的，沒有資料~~");
116             return;
117         }
118         for (int i = 0; i < arr.length; i++) {
119             System.out.printf("arr[%d]=%d\n", i, arr[i]);
120         }
121     }
122 
123     // 顯示佇列的頭資料， 注意不是取出資料
124     public int headQueue() {
125         // 判斷
126         if (isEmpty()) {
127             throw new RuntimeException("佇列空的，沒有資料~~");
128         }
129         return arr[front + 1];
130     }
131 }

-》問題優化

（1）目前陣列使用一次就不能使用， 沒有達到複用的效果。

（2）將這個陣列使用演算法，改進成一個環形的佇列 取模：%

陣列模擬環形佇列

對前面的陣列模擬佇列的優化，充分利用陣列。因此將陣列看做是一個環形的。（通過取模的方式來實現即可）

-》分析說明：

（1）尾索引的下一個為頭索引時表示佇列滿，即將佇列容量空出一個作為約定，這個在做判斷佇列滿的時候需要注意（rear+1）%maxSize==front【滿】

（2）rear==front【空】

（3）分析示意圖：

-》程式碼實現：

  1 package com.atguigu.queue;
  2 
  3 import java.util.Scanner;
  4 
  5 public class CircleArrayQueueDemo {
  6 
  7     public static void main(String[] args) {
  8         
  9         //測試一把
 10         System.out.println("測試陣列模擬環形佇列的案例~~~");
 11         
 12         // 建立一個環形佇列
 13         CircleArray queue = new CircleArray(4); //說明設定4, 其佇列的有效資料最大是3
 14         char key = ' '; // 接收使用者輸入
 15         Scanner scanner = new Scanner(System.in);//
 16         boolean loop = true;
 17         // 輸出一個選單
 18         while (loop) {
 19             System.out.println("s(show): 顯示佇列");
 20             System.out.println("e(exit): 退出程式");
 21             System.out.println("a(add): 新增資料到佇列");
 22             System.out.println("g(get): 從佇列取出資料");
 23             System.out.println("h(head): 檢視佇列頭的資料");
 24             key = scanner.next().charAt(0);// 接收一個字元
 25             switch (key) {
 26             case 's':
 27                 queue.showQueue();
 28                 break;
 29             case 'a':
 30                 System.out.println("輸出一個數");
 31                 int value = scanner.nextInt();
 32                 queue.addQueue(value);
 33                 break;
 34             case 'g': // 取出資料
 35                 try {
 36                     int res = queue.getQueue();
 37                     System.out.printf("取出的資料是%d\n", res);
 38                 } catch (Exception e) {
 39                     // TODO: handle exception
 40                     System.out.println(e.getMessage());
 41                 }
 42                 break;
 43             case 'h': // 檢視佇列頭的資料
 44                 try {
 45                     int res = queue.headQueue();
 46                     System.out.printf("佇列頭的資料是%d\n", res);
 47                 } catch (Exception e) {
 48                     // TODO: handle exception
 49                     System.out.println(e.getMessage());
 50                 }
 51                 break;
 52             case 'e': // 退出
 53                 scanner.close();
 54                 loop = false;
 55                 break;
 56             default:
 57                 break;
 58             }
 59         }
 60         System.out.println("程式退出~~");
 61     }
 62 
 63 }
 64 
 65 
 66 class CircleArray {
 67     private int maxSize; // 表示陣列的最大容量
 68     //front 變數的含義做一個調整： front 就指向佇列的第一個元素, 也就是說 arr[front] 就是佇列的第一個元素 
 69     //front 的初始值 = 0
 70     private int front; 
 71     //rear 變數的含義做一個調整：rear 指向佇列的最後一個元素的後一個位置. 因為希望空出一個空間做為約定.
 72     //rear 的初始值 = 0
 73     private int rear; // 佇列尾
 74     private int[] arr; // 該資料用於存放資料, 模擬佇列
 75     
 76     public CircleArray(int arrMaxSize) {
 77         maxSize = arrMaxSize;
 78         arr = new int[maxSize];
 79     }
 80     
 81     // 判斷佇列是否滿
 82     public boolean isFull() {
 83         return (rear  + 1) % maxSize == front;
 84     }
 85     
 86     // 判斷佇列是否為空
 87     public boolean isEmpty() {
 88         return rear == front;
 89     }
 90     
 91     // 新增資料到佇列
 92     public void addQueue(int n) {
 93         // 判斷佇列是否滿
 94         if (isFull()) {
 95             System.out.println("佇列滿，不能加入資料~");
 96             return;
 97         }
 98         //直接將資料加入
 99         arr[rear] = n;
100         //將 rear 後移, 這裡必須考慮取模
101         rear = (rear + 1) % maxSize;
102     }
103     
104     // 獲取佇列的資料, 出佇列
105     public int getQueue() {
106         // 判斷佇列是否空
107         if (isEmpty()) {
108             // 通過丟擲異常
109             throw new RuntimeException("佇列空，不能取資料");
110         }
111         // 這裡需要分析出 front是指向佇列的第一個元素
112         // 1. 先把 front 對應的值保留到一個臨時變數
113         // 2. 將 front 後移, 考慮取模
114         // 3. 將臨時儲存的變數返回
115         int value = arr[front];
116         front = (front + 1) % maxSize;
117         return value;
118 
119     }
120     
121     // 顯示佇列的所有資料
122     public void showQueue() {
123         // 遍歷
124         if (isEmpty()) {
125             System.out.println("佇列空的，沒有資料~~");
126             return;
127         }
128         // 思路：從front開始遍歷，遍歷多少個元素
129         // 動腦筋
130         for (int i = front; i < front + size() ; i++) {
131             System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
132         }
133     }
134     
135     // 求出當前佇列有效資料的個數
136     public int size() {
137         // rear = 2
138         // front = 1
139         // maxSize = 3 
140         return (rear + maxSize - front) % maxSize;   
141     }
142     
143     // 顯示佇列的頭資料， 注意不是取出資料
144     public int headQueue() {
145         // 判斷
146         if (isEmpty()) {
147             throw new RuntimeException("佇列空的，沒有資料~~");
148         }
149         return arr[front];
150     }
151 }