【数据结构与算法(java)】数组模拟环形队列

数组模拟环形队列

• 用来避免普通队列的“假溢出”问题。

• 思路：front与rear变量含义调整：front直接指向队列第一个元素，rear指向最后一个元素的后一个位置。空出一个空间作为约定。front和rear的初始值都变为0。

• 为什么要空出一个位置？用牺牲一个存储空间换取状态判断的唯一性。

  空队列：front==rear;

  慢队列：(rear+1)%maxSize==front;（即尾指针的下一个位置等于头指针，从而避免了两种状态的判断冲突）

• 当队列满时，条件以前是rear==maxSize-1，现在变为(rear+1)%maxSize==front;

• 队列为空的条件，rear==front空。

• 队列中有效的数据个数(rear-front+maxSize)%maxSize;

  import java.util.Scanner;
  
  public class CircleArrayQueueDemo {
  
      public static void main(String[] args) {
          CircleQueue circleQueue = new CircleQueue(4);
          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): 添加数据到队列");
              System.out.println("g(get): 从队列取出数据");
              System.out.println("h(head): 查看队列头的数据");
              key = scanner.next().charAt(0);
              switch (key) {
                  case 's':
                      circleQueue.showQueue();
                      break;
                  case 'a':
                      System.out.println("输出一个数");
                      int value = scanner.nextInt();
                      circleQueue.addQueue(value);
                      break;
                  case 'g':
                      try {
                          int res = circleQueue.getQueue();
                          System.out.printf("取出的数据是%d\n", res);
                      } catch (Exception e) {
                          //TODO: handle exception
                          System.out.println(e.getMessage());
                      }
                      break;
                  case 'h':
                      try {
                          int res = circleQueue.headQueue();
                          System.out.printf("队列头的的数据是%d\n", res);
                      } catch (Exception e) {
                          //TODO: handle exception
                          System.out.println(e.getMessage());
                      }
                      break;
                  case 'e':
                      scanner.close();
                      loop = false;
                      break;
                  default:
                      throw new AssertionError();
              }
          }
          System.out.println("程序退出");
      }
  }
  
  class CircleQueue {
  
      private int maxSize;
      private int front; // 指向第一个元素
      private int rear; // 指向最后一个元素的后一个位置
      private int[] arr;
  
      public CircleQueue(int arrMaxSize) {
          maxSize = arrMaxSize;
          arr = new int[maxSize];
          front = 0;
          rear = 0;
      }
  
      public boolean isFull() {
          return (rear + 1) % maxSize == front;
      }
  
      public boolean isEmpty() {
          return rear == front;
      }
  
      public void addQueue(int n) {
          if (isFull()) {
              System.out.println("队列满");
              return;
          }
          arr[rear] = n;
          rear = (rear + 1) % maxSize;
      }
  
      public int getQueue() {
          if (isEmpty()) {
              throw new RuntimeException("队列空，不能取数据");
          }
          int res = arr[front];
          front = (front + 1) % maxSize;
          return res;
      }
      public int headQueue() {
          if (isEmpty()) {
              throw new RuntimeException("队列空，不能取数据");
          }
          int res = arr[front];
          return res;
      }
  
      public void showQueue() {
          if (isEmpty()) {
              System.out.println("队列为空");
              return;
          }
          // ohh
          for (int i = front; i < front + size(); i++) {
              System.out.printf("arr[%d] = %d  ", i % maxSize, arr[i % maxSize]);
          }
      }
  
      public int size() {
          return (rear - front + maxSize) % maxSize;
      }
  }