数组模拟队列

1) 队列是一个 有序列表 ，可以用 数组 或是 链表 来实现。

2) 遵循 先入先出 的原则。即： 先存入队列的数据，要先取出。后存入的要后取 出

3) 示意图： ( 使用数组模拟队列示意图 )

 

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

 

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

 

当我们将数据存入队列时称为” addQueue ”， addQueue 的处理需要有两个步骤：思路分析

1) 将尾指针往后移： rear+1 , 当 front == rear 【空】

2) 若尾指针 rear 小于队列的最大下标 maxSize-1 ，则将数据存入 rear 所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满 ]

 

代码实现

import javax.naming.ldap.LdapReferralException;
import java.util.Scanner;

public class ArrayQueue {
    public static void main(String[] args) {
        //测试一下
        Queue q=new Queue(10);//创建一个队列
        char key=' ';//用来接收用户输入
        Scanner sc=new Scanner(System.in);
        boolean loop=true;
        //输出一个菜单
        while (loop){
            System.out.println("s(show)：显示队列");
            System.out.println("a(add)：添加数据到队列");
            System.out.println("g(getQueue)：从队列中移除数据");
            System.out.println("h(headQueue)：读取队首数据");
            System.out.println("e(exit)：退出队列");
            key = sc.next().charAt(0);//接收一个字符
            switch (key){
                case 'a':
                    System.out.println("输入一个您想加入的数");
                    int value=sc.nextInt();
                    q.add(value);
                    break;
                case 's':
                    q.listQueue();
                    break;
                case 'g':
                    try {
                        int res = q.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int res=q.headQueue();
                        System.out.printf("队列的头数据是%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    sc.close();
                    loop=false;
                    System.out.println("程序退出");
                    break;
                default:
                    break;
            }

        }

    }
    //使用数组模拟一个队列，写一个类
    static class Queue{
        private int MaxSize;//数组最大容量，即队列的容量
        private int front;//头指针
        private int rear;//尾指针
        private int[] arr;//用来存放数据，模拟队列
        //创建队列的构造器
        public Queue(int MaxSize){
            this.MaxSize=MaxSize;
            this.front=-1;//指向队列头部，即指向队列头前一个位置
            this.rear=-1;//指向队列尾部
            this.arr=new int[MaxSize];
        }

        //判断队列是否为满
        public boolean isFull(){
            return rear==MaxSize-1;
        }
        //判断队列是否为空
        public boolean isEmpty(){
            return front==rear;
        }
        //添加数据到队列
        public void add(int n){
            if(isFull()){
                System.out.println("队列满，不能加入数据");
                return;
            }
            arr[++rear]=n;//rear先后移，再给其对应位置赋值，表示加入队列
        }
        //获取队列数据，出队列
        public int getQueue(){
            //判断队列是否为空
            if(isEmpty()){
                //通过抛出异常
                throw new RuntimeException("队列为空，不能读取数据");
            }
            front++;//front后移
            return arr[front];
        }
        //显示队列的所有数据
        public void listQueue(){
            //遍历
            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()){
                throw  new RuntimeException("队列空，没有数据");
            }
            return arr[front+1];//front指向队列头前一个位置，所以要加1
        }
    }
}

 

问题分析并优化

1) 目前数组使用一次就不能用， 没有达到复用的效果

2) 将这个数组使用算法，改进成一个 环形的队列 取模：%，见下一篇   数组模拟循环队列