数组模拟队列&&数组模拟环形队列

队列介绍

队列是一个有序列表，可以用数组或是链表来实现。
遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
示意图：(使用数组模拟队列示意图)

数组模拟队列

队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。

因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示:

数组模拟队列

当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤：思路分析
将尾指针往后移：rear+1 , 当front == rear 【空】
若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]

代码实现
问题分析并优化

class ArrayQueue(arrMaxSize: Int) { val maxSize: Int = arrMaxSize
val array = new ArrayInt
var front: Int = -1
var rear: Int = -1
}

//初始化
val queue = new ArrayQueue(3)

rear 是队列最后[含]
front 是队列最前元素[不含]

数组模拟队列

出队列操作getQueue
显示队列的情况showQueue
查看队列头元素headQueue
退出系统exit

将原来的队列的查看队列头元素的代码写完.

代码示例：

package com.madi.queue;

import com.sun.jmx.remote.internal.ArrayQueue;

import java.util.Scanner;

public class TestQueue {
    public static void main(String[] args) {
          //测试一把
            //创建一个队列
           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):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列头的数据");
            key=scanner.next().charAt(0);//接收一个字符
            switch (key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输出一个数");
                    int value=scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g'://取出数据
                    try {
                      int res=queue.getQueue();
                      System.out.printf("取出的数据是%d\n",res);
                    }catch (Exception e){
                           System.out.println(e.getMessage());
                    }
                    break;
                case 'h'://查看队列头的数据
                     try {
                      int res=queue.headQueue();
                      System.out.printf("队列头的数据是%d\n",res);
                     }catch (Exception e){
                           System.out.println(e.getMessage());
                     }
                    break;
                case 'e'://退出
                     scanner.close();
                     loop=false;
                    break;

                    default:
                        break;
            }
        }
        System.out.println("程序退出--");
    }

    static class  ArrayQueue {
        private int maxSize;//表示数组的最大容量
        private int front;//队列头
        private int rear;//队列尾
        private int[] arr;//该数据用于模拟数据，存放队列

        //创建队列的构造器
        public ArrayQueue(int arrMxSize) {
            maxSize = arrMxSize;
            arr = new int[maxSize];
            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(isFull()){
                    System.out.println("队列空的，没有数据");
                    throw new RuntimeException();
                }
                return  arr[front+1];
            }
    }




}

数组模拟环形队列

package com.madi.queue;

import java.util.Scanner;

public class CircleArraryQueue  {
    public static void main(String[] args) {
              //测试案例
        System.out.println("测试数组模拟环形队列的案例");
        //创建一个环形队列
        CircleArrary queue=new CircleArrary(4);//说明设置4，其队列的有效数据最大是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 'a':
                    System.out.println("输出一个数");
                    int value=scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g'://取出数据
                    try {
                        int res=queue.getQueue();
                        System.out.printf("取出的数据是%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h'://查看队列头的数据
                    try {
                        int res=queue.headQueue();
                        System.out.printf("队列头的数据是%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e'://退出
                    scanner.close();
                    loop=false;
                    break;

                default:
                    break;
            }
        }
        System.out.println("程序退出--");
    }

    static class  CircleArrary{
        private int maxSize;//表示数组的最大容量
        //front 变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front]
        //front 的初始值=0；
        private int front;//队列头

        //rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个位置
        //rear的初始值为=0
        private int rear;//队列尾
        private int[] arr;//该数据用于模拟数据，存放队列

        //创建队列的构造器
        public CircleArrary(int arrMxSize) {
            maxSize = arrMxSize;
            arr = new int[maxSize];

        }
        //判断队列是否满
          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=(rear+1)%maxSize;
        }
           //获取队列的数据，出队列
         public  int getQueue(){
            //判断队列是否为空
             if(isEmpty()){
                 //通过抛出异常
                 throw  new RuntimeException("队列空，不能取数据");

             }
             //这里需要先分析出front是指向队列的第一个元素
             //1.先把front的值保存到一个临时变量
             //2.将front后移,
             //3.将临时保存的变量返回
             int value=arr[front];
             front=(front+1)%maxSize;
              return  value;



         }
         //显示队列的所有数据
        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(isFull()){
                    System.out.println("队列空的，没有数据");
                    throw new RuntimeException();
                }
                return  arr[front];
            }
    }




}