• 佇列的特點

  1.可以使用陣列和連結串列兩種方式來實現。

  2.遵循先入先出(FIFO)的規則，即先進入的資料先出。

  3.屬於有序列表。

• 圖解實現過程：

​ 1.定義一個固定長度的陣列，長度為maxSize。

​ 2.設定兩個指標first = -1（指向佇列第一個資料的前一位，這樣保證在新增第一 個數據以後頭指標為0，和陣列的下標一樣，且用於操作出隊）和last = -1(指向 隊尾，用於操作入隊)。

​ 3.即first會因為出隊操作而增加，last會因為入隊操作而增加

---

• 程式碼實現：

  package 佇列;
  
  public class ArrayQueueTest {
      public static void main(String[] args) {
          ArrayQueue arrayQueue = new ArrayQueue(3);
          arrayQueue.addQueue("瓊");
          arrayQueue.addQueue("贇");
          arrayQueue.addQueue("瓏");
          arrayQueue.showAllQueueData();
          System.out.println(arrayQueue.getQueue());   
      }
  }
  class ArrayQueue{
      private int maxSize;//定義佇列的最大長度
      private int first ;//指向佇列頭的前一個位置！！前一個位置！！出隊方向
      private int last ;//指向佇列尾部!!即最後一個數據！！！入隊方向
      private String[] arr; //先建一個空的陣列，具體長度未知，需要maxSize來確定。
  
      //構造器初始化佇列資訊
      public ArrayQueue(int maxSize){
          this.maxSize = maxSize;
          this.first = -1;
          this.last = -1;
          arr = new String[maxSize];
      }
  
      //判斷是否為空
      public boolean isEmpty(){
          if (first == last) {
              System.out.println("佇列為空~~");
              return true;
          }else {
              System.out.println("佇列不為空~~");
              return false;
          }
      }
  
      //判斷佇列是否滿
      public boolean isFull(){
          if (last == maxSize-1) {
              System.out.println("佇列已滿~~");
              return true;
          }else {
              System.out.println("佇列未滿~~");
              return false;
          }
      }
  
      //入隊
      public void addQueue(String data){
          if (last == maxSize-1){
              System.out.println("佇列已滿，不能再新增！！");
              return;
          }else {
              last++; //新增資料只和末尾下標有關
              arr[last] = data;
              return;
          }
      }
  
      //出隊
      public String getQueue(){
          if (isEmpty()) {
              //因為getQueue方法是int型，需要返回資料，如果無資料，也需要返回
              //如果返回-1或者其他資料，會讓人誤解獲取到的數就是-1或者其他
              //所以用丟擲異常來處理
              throw new RuntimeException("佇列為空，無資料~~");
          }
          else {
              first++;
              return arr[first];
          }
      }
  
      //遍歷佇列所有資訊
      public void showAllQueueData(){
          if (first == last){
              return;
          }
          for (int i = 0; i < arr.length; i++) {
              System.out.println("arr["+i+"]"+"="+arr[i]);
          }
      }
  
      //獲取佇列頭資料
      public String headQueueData(){
          if (isEmpty()){
              throw new RuntimeException("無資料~~~");
          }
          return arr[++first];
      }
  }
   
  

• 缺點：

  由於出隊操作，使得first指標上移變大，導致陣列前面空出來的位置就不能再繼續新增資料，即不能再被重複使用，這樣一個佇列只能使用一次，記憶體效率太低，所以需要使用環形佇列來優化解決。

• 優化解決——環形佇列實現思路

  1.first指標初始預設設定為0，指向佇列頭部，則arr[first] 就是第一個資料。

  2.last指標初始預設也為0，但是會隨著增加資料而後移。

  3.佇列滿的條件：

  (last + 1) % maxSize ==  first

  ​ last+1是為了讓指標後移，而且如果不設定為 last+1 那麼一開始的時候last為0 ，   last % maxSize == 0，且first也為0，還沒加資料就滿了。

  4.佇列為空的條件：

  first == last  

  5.由於判斷是否滿的時候： last+1 ，導致實際上可以裝的資料比陣列長度少 1

---

• 環形佇列各步驟及各方法實現講解

  1.佇列初始化 ：

  class CircleArryQueue{
      private int maxSize ; //陣列長度，即佇列最大容量
      private int first;      //頭指標，控制出隊操作
      private int last;   //尾指標，控制入隊操作
      private int[] arr;      //陣列型別，可以換其他的。
  
      //構造器初始化資訊
      public CircleArryQueue(int maxSize){
          this.maxSize = maxSize;
          this.arr = new int[maxSize];
          this.first = 0;       //這兩個可以不加，不叫也是預設為0
          this.last = 0;
      }
  }
   
  

  2.判斷佇列是否為空：

   public boolean isEmpty(){
          //頭指標和尾指標一樣 則說明為空
          return last == first;
      }

  3.判斷佇列是否滿：

  /*
  *這裡的 last+1 主要是為了讓指標後移，特別是在佇列尾部新增資料的時候，本來用last也可以判斷，但
  *是一開始還沒加資料的時候，如果直接用last % maxSize == first，結果是true，所以為了解決指標後*移和判斷是否滿，用來last+1。其次，因為last+1可能會導致陣列指標越界，所以用取模來控制它的範  * 圍，同時保證他會在一個固定的範圍迴圈變換，也利於環形佇列的實現。
  */
  public boolean isFull(){
      return (last + 1) % maxSize == first;
  }
  

  4.新增資料到佇列尾部：入隊

  public void pushData(int data){
      //先判斷是否滿了
      if(isFull()){
          System.out.println("佇列已經滿啦~~");
          return;
      }
      arr[last] = data;
      //last+1是為了後移，取模是為了避免指標越界，同時可以讓指標迴圈
      last = (last + 1) % maxSize;
  }

  5.取出隊首資料：出隊

  public int popData(){
          if (isEmpty()) {
              //拋異常就可以不用返回資料了
              new RuntimeException("佇列為空，沒有獲取到資料~~");
          }
  
        //要先把first對應的陣列資料儲存——>first後移——>返回資料
          int value = arr[first];
        //first+1的操作和last+1是一樣的，取模也是 
          first = (first+1) % maxSize;
          System.out.println(value);
          return value;
        //如果不儲存first指標 那麼返回的資料就不對了
        //如果直接返回資料，那first指標還沒後移 也不對，所以需要使用第三方變數
      }

  6.展示佇列中所有資料：

  public void showAllData(){
          if (isEmpty()) {
              System.out.println("佇列為空，沒有資料~~");
              return;
          }
        //此處i不為0，是因為有可能之前有過popData()操作，使得firs不為0，所以最好使用
        //first給i動態賦值，
          for (int i = first; i < first+size() ; i++) {
              System.out.println("arr["+i%maxSize+"]"+arr[i%maxSize]);
          }

  7.獲取佇列中資料的總個數：

  public int dataNum(){
    //韓順平老師的教程上是這樣寫，但是我理解不了..........。
    return (last+maxSize-first) % maxSize;   
  }

  8.檢視隊首資料但不彈出：

  public void seeFirstData(){
      return arr[first];
  }

---

• 全部程式碼整合：

  package 練習;
  
  import java.util.Scanner;
  
  public class CircleArryQueue {
      public static void main(String[] args){
          CircleQueue circleQueue = new CircleQueue(4);
          System.out.println("--------測試環形佇列--------");
          char key = ' ';
          Scanner scanner = new Scanner(System.in);
  
          boolean flag = true;
          while (flag){
              System.out.println("s(showAllData):檢視佇列資料");
              System.out.println("p(pushData):隊尾新增資料");
              System.out.println("g(popData):彈出隊頭資料");
              System.out.println("h(seefirstData)：獲取隊頭資料");
              System.out.println("e(exit):退出程式");
              key = scanner.next().charAt(0);
  
              switch (key){
                  case 's':
                      circleQueue.showAllData();
                      break;
                  case 'p':
                      System.out.println("輸入一個數據：");
                      int obj = scanner.nextInt();
                      circleQueue.pushData(obj);
                      break;
                  case 'g':
                      circleQueue.popData();
                      break;
                  case 'h':
                      circleQueue.seeFirstData();
                      break;
                  case 'e':
                      scanner.close();
                      flag = false;
                      break;
                  default:
                      break;
              }
  
          }
  
          System.out.println("程式結束~~~");
  
      }
  
  }
  
  class CircleQueue {
      private int maxSize ; //陣列長度，即佇列最大容量
      private int first;      //頭指標，控制出隊操作
      private int last;   //尾指標，控制入隊操作
      private int[] arr;      //陣列型別，可以換其他的。
  
      //構造器初始化資訊
      public CircleQueue(int maxSize){
          this.maxSize = maxSize;
          this.arr = new int[maxSize];
          this.first = 0;       //這兩個可以不加，不叫也是預設為0
          this.last = 0;
      }
  
      public boolean isEmpty(){
          //頭指標和尾指標一樣 則說明為空
          return last == first;
      }
  
  /*
  *這裡的 last+1 主要是為了讓指標後移，特別是在佇列尾部新增資料的時候，本來用last也可以判斷但
  *是一開始還沒加資料的時候，如果直接用last % maxSize == first，結果是true，所以為了解決指標
  *後移和判斷是否滿，用來last+1。其次，因為last+1可能會導致陣列指標越界，所以用取模來控制它
  *的範圍，同時保證他會在一個固定的範圍迴圈變換，也利於環形佇列的實現。
  */
      public boolean isFull(){
          return (last + 1) % maxSize == first;
      }
  
      public void pushData(int data){
          //先判斷是否滿了
          if(isFull()){
              System.out.println("佇列已經滿啦~~");
              return;
          }
          arr[last] = data;
          //last+1是為了後移，取模是為了避免指標越界，同時可以讓指標迴圈
          last = (last + 1) % maxSize;
      }
  
      public int popData(){
          if (isEmpty()) {
              //拋異常就可以不用返回資料了
              throw new RuntimeException("佇列為空，沒有獲取到資料~~");
          }
  
          //要先把first對應的陣列資料儲存——>first後移——>返回資料
          int value = arr[first];
          //first+1的操作和last+1是一樣的，取模也是
          first = (first+1) % maxSize;
          System.out.println(value);
          return value;
          //如果不儲存first指標 那麼返回的資料就不對了
          //如果直接返回資料，那first指標還沒後移 也不對，所以需要使用第三方變數
      }
  
    //檢視所有資料
      public void showAllData(){
          if (isEmpty()) {
              System.out.println("佇列為空，沒有資料~~");
          }
          //此處i不為0，是因為有可能之前有過popData()操作，使得firs不為0，所以最好使用
          //first給i動態賦值，
          for (int i = first; i < first+dataNum() ; i++) {
              System.out.println("arr["+i%maxSize+"]"+arr[i%maxSize]);
          }
      }
    //檢視有效資料個數
      public int dataNum(){
          //韓順平老師的教程上是這樣寫，但是我理解不了..........。
          return (last+maxSize-first) % maxSize;
      }
    //檢視佇列第一個資料
      public int seeFirstData(){    
          System.out.println(arr[first]);
          return arr[first];
  
      }
  }

---

• 最後：

  部分內容參考自B站韓順平老師java資料結構課程，由於筆者水平有限，整理的博文中難免有不不足和理解不對的地方，歡迎留言批評指正。碼字不易，除錯費神。歡迎轉載轉發，但請註明出處。如有幫助，歡迎打賞一杯咖啡除錯bug。

相關推薦