队列

队列介绍

• 队列是一个有序列表,可以用数组或者链表来实现
• 遵循先入先出的原则.即:先存入队列的数据,要先取出.后存入的要后取出
• 示意图:

数组模拟队列思路

• 队列本身是有序列表,若使用数组的结构来存储队列的数据,则队列数组的声明如上图,其中 maxSize是该队列的最大容量.
• 因为队列的输出,输入分别从前后端来处理,因此需要两个变量 front及 rear分别记录队列前后端的下标,front会随着数据输出而改变,而 rear则是随着数据输入而改变.

解题思路

• 当我们将数据存入队列时称为 addQueue,addQueue的处理需要两个步骤:
  1. 将尾指针往后移: rear+1,当 front==rear [空]
  2.  若尾指针 rear小于队列的最大下标 maxSize-1,则价格数据存入 rear所指的数组元素,否则无法存入数据.rear == maxSize-1  [队列满]
  3. rear是队列最后[含]
  4. front是队列最前元素[不含]
• 代码实现
  点击查看代码

  public class ArrayQueueDemo {
  
      public static void main(String[] args) {
          //测试
          //创建一个队列
          ArrqyQueue queue = new ArrqyQueue(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):添加数据到队列");
              System.out.println("g(get):从队列取出数据");
              System.out.println("h(head):查看队列头的数据");
              key = scanner.next().charAt(0);//接收一个字符
              switch (key) {
                  case 's':
                      queue.showQueue();
                      break;
                  case 'e':
                      loop = false;
                      scanner.close();
                      break;
                  case 'a':
                      System.out.println("请输入一个数");
                      queue.addQueue(scanner.nextInt());
                      break;
                  case 'g':
                      try {
                          int res = queue.getQueue();
                          System.out.printf("取出的数据是%d\n", res);
                      } catch (Exception e) {
                          System.out.println(e.getMessage());//Exception(String message)
                      }
                      break;
                  case 'h':
                      try {
                          System.out.printf("队列头的数据是%d\n" + queue.headQueue());
                      } catch (Exception e) {
                          System.out.println(e.getMessage());
                      }
                      break;
                  default:
                      System.out.println("输入有误");
              }
  
          }
          System.out.println("程序退出");
      }
  
  }
  
  //使用数组模拟队列-编写一个ArrayQueue类
  class ArrqyQueue {
      private int maxSize;//表示数组的最大容量
      private int front;//队列头
      private int rear;//队列尾
      private int[] arr;//该数组用于存放数据，模拟队列
  
      //创建队列的构造器
      public ArrqyQueue(int arrayMaxSize) {
          maxSize = arrayMaxSize;
          arr = new int[arrayMaxSize];
          front = -1;//指向队列头部，并不包含，分析出 front是指向队列头的前一个位置
          rear = -1;//指向队列尾，指向队列尾的数据(即就是队列最后一个数据)
      }
  
      //判断队列是否满
      public boolean isFull() {
          return rear == maxSize - 1;
      }
  
      //判断队列是否为空
      public boolean isEmpty() {
          return rear == front;
      }
  
      //添加数据到队列
      public void addQueue(int n) {
          //判断队列是否满
          if (isFull()) {
              System.out.println("队列满，不能添加数据");
              return;
          }
          rear++;//让 rear 后移
          arr[rear] = n;
      }
  
      //获取队列的数据，出队列
      public int getQueue() {
          //判断队列是否空
          if (isEmpty()) {
              //通过抛出异常处理
              throw new RuntimeException("队列空，不能获取数据");
          }
          front++;//front 后移就可以取出数据
          return arr[front];
      }
  
      //显示队列的所有数据
      public void showQueue() {
          if (isEmpty()) {
              System.out.println("队列空的，没有数据");
              return;
          }
          for (int i = 0; i < arr.length; i++) {
              System.out.printf("arr[%d]=%d\n", i, arr[i]);
          }
      }
  
      //显示队列的头数据，注意不是取出数据
      public int headQueue() {
          //判断
          if (isEmpty()) {
              System.out.println("");
              throw new RuntimeException("队列空的，没有数据");
          }
          return arr[front + 1];//front是指向队列头的前一个位置
      }
      
  }

问题分析并优化

1. 目前数组使用一次就不能用,没有达到复用的效果.
2. 将这个数组使用算法,改进成一个环形的队列  %

优化:数组模拟环形队列

对前面的数组模拟队列的有点充分利用数组因此将数组看做是一个环形的.(通过取模的方式来实现即可)

分析说明:

1. front 变量的含义做一个调整: front就指向队列的第一个元素,也就是 arr[front] 就是队列的第一个元素
   • front 的初始值 = 0
2. rear变量的含义做一个调整: rear指向队列的最后一个元素的最后一个位置:因为希望空出一个空间做约定
   • rear 的初始值 = 0
3. 但队列满时,条件是 (rear+1)%maxSize==front  [满]
   • rear 总比 maxSize大一 正好取模就等于0
4. 队列为空的条件 rear == front [空]
5. 当我们这样分析,队列中有效的数据的个数 (rear+maxSize-front)%maxSize  //raer=1 front=0
6. 我们就可以在原来的队列上修改得到,一个环形队列.

代码实现

点击查看代码

//使用数组模拟队列-编写一个ArrayQueue类
class CircleArrayQueue {
    private int maxSize;//表示数组的最大容量
    //front 变量的含义做一个调整: front就指向队列的第一个元素,也就是 arr[front] 就是队列的第一个元素
    //初始容量0
    private int front;//队列头
    //rear变量的含义做一个调整: rear指向队列的最后一个元素的最后一个位置:因为希望空出一个空间做约定
    //初始容量0
    private int rear;//队列尾
    private int[] arr;//该数组用于存放数据，模拟队列

    //创建队列的构造器
    public CircleArrayQueue(int arrayMaxSize) {
        maxSize = arrayMaxSize;
        arr = new int[arrayMaxSize];
        //front = 0;rear = 0;
    }


    //添加数据到队列
    public void addQueue(int n) {
        //判断队列是否满
        if (isFull()) {
            System.out.println("队列满，不能添加数据");
            return;
        }
        //直接将数据加入就可以了
        arr[rear] = n;
        //将 rear后移，这里必须考虑取模
        rear = (rear + 1) % maxSize;
    }

    //获取队列的数据，出队列
    public int getQueue() {
        //判断队列是否空
        if (isEmpty()) {
            //通过抛出异常处理
            throw new RuntimeException("队列空，不能获取数据");
        }
        /*
         * 这里需要分析出 front 是指向队列的第一个元素
         * 1. 先把 front对应的值保留一个临时变量
         * 2. 将 front后移,考虑取模
         * 3. 将临时保存的变量返回
         * */
        int temp = arr[front];
        front = (front + 1) % maxSize;
        return temp;
    }

    //显示队列的所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列空的，没有数据");
            return;
        }
        //思路，从 front开始遍历，遍历多少个元素
        for (int i = front; i < front + size(); i++) {
            System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
        }
    }

    //求出当前队列有效数据的个数
    public int size() {
        //rear = 1 ，front = 0 ，maxSize=3
        return (rear + maxSize - front) % maxSize;
    }

    //显示队列的头数据，注意不是取出数据
    public int headQueue() {
        //判断
        if (isEmpty()) {
            System.out.println("");
            throw new RuntimeException("队列空的，没有数据");
        }
        return arr[front];//front是指向队列头的第一个位置
    }

    //判断队列是否满
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

    //判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }
}