队列和环形队列用数组的实现

队列简介

队列就是一个有序的列表，可以用数组和链表来实现

1	2	3	4	5	……

遵循的原则是先入先出原则，先存入队列的数据，先被取出，后存入的数据，后被取出。

图a是描述用数组实现队列的存元素，maxsize表示队列最大的容量。存的过程中，永远是从队尾存储元素，front指向队首的前一个位置，并且初始值为-1，rear指向队尾，初始值也为-1，故存储时front不变，而rear会增加。
图b表示利用数组实现队列的取元素，取的过程中，永远是从队首取元素，故rear不变，front会增加

队列实现

思路分析

首先要有的变量：
front :表示队首元素的前一个位置
rear ：表示队尾元素
maxsize ：表示能存储的最大元素数目
Array[ ] ：用数组实现队列

存数据时思路：自定义的addQueue方法

1. 当front=rear，表示数组为空，可以存放数据
2. 若指针尾部，rear<maxsize-1,则表示可以继续存放元素，并且让rear+1
3. 若rear==maxsize-1，则表示队列已经满了，不能存放

取数据时思路：自定义的removeQueue方法

1. 首先判断队列中的元素是否为空，若为空则直接返回
2. 不为空则取元素，返回下标为front+1的队首元素

代码实现：

package com.njupt;
import java.util.Scanner;

/**
 * Creat with IntelliJ IDEA
 *
 * @Date:2021/07/12/17:00
 * @Description:用数组实现队列
 */
public class ArrayQueue {
    public static void main(String[] args) {
        Queue queue = new Queue(4);
        char key=' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop=true;
        while(true){
            System.out.println("s代表显示队列，e代表退出，a代表添加，r代表remove，p代表查看列头部数据");
            key=scanner.next().charAt(0);
            switch(key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数");
                    int num=scanner.nextInt();
                    queue.addQueue(num);
                    break;
                case 'r':
                    try {
                        int item = queue.removeQueue();
                        System.out.println("取出的数据是"+item);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'p':
                    try {
                        int head=queue.peekQueue();
                        System.out.println("头部元素是"+head);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop=false;
                default:
                    break;
            }
        }

    }
}
class Queue{
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;

    public Queue(int num){
        maxSize=num;
        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 num){
        if(isFull()){
            System.out.println("队列已满，不能在加元素");
            return;
        }
        rear++;
        arr[rear]=num;//因为rear指向最后一个元素，故添加元素时要添加到后一位。
    }
    //取元素的方法
    public int removeQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");
        }
        front++;//front指向的是队首的前一个位置，当要取出队首元素时，要＋1
        return arr[front];//取出队首元素
    }
    //遍历队列的方法
    public void showQueue(){
        if(isEmpty()){
            System.out.println("队列为空！");
            return;
        }
        for(int i=0;i<arr.length;i++){
            System.out.print("\t"+arr[i]);
        }
    }
    //显示数据头的方法
    public int peekQueue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空");

        }
        return arr[front+1];//因为front指向的是队列头部的前一个位置
    }
}

问题：经过测试之后，发现队列不能重复使用，只能使用一次，当队列满之后，即使移除其他的元素，仍然不能在此使用，显示队列已满问题。故引入环形队列。

环形队列

对前面的数组模拟队列的优化，充分利用数组，通过取余，将数组看成一个环形结构

改进思路

1. front变量含义从原来的队首元素的前一位调整成就指向第一位元素，也就是arr[front]就是第一个元素，初始值为0
2. rear变量含义的调整：rear从指向队列的最后一个元素，变成指向最后一个元素的后一个位置，因为希望空出一个空间作为一个约定，rear的初始值为0
3. 当队列满时的条件为：（rear+1）%maxsize==front
4. 当队列空时，rear==front
5. 数据中有效的数据个数为：（rear+maxsize-front)%maxsize
6. 根据以上条件可以把原来的队列修改成一个环形队列。

环形队列代码的实现

package com.njupt.queue;

import java.util.Scanner;

/**
 * Creat with IntelliJ IDEA
 *
 * @Date:2021/07/12/20:16
 * @Description:利用数组实现环形队列！
 */
public class CircleArrayQueue {
    public static void main(String[] args) {
        CircleQueue queue = new CircleQueue(4);//虽然设置4，但是队列有效数据个数为3个，因为设置了一个预留位置rear
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (true) {
            System.out.println("s代表显示队列，e代表退出，a代表添加，r代表remove，p代表查看列头部数据");
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    queue.showCircleQueue();
                    break;
                case 'a':
                    System.out.println("请输入一个数");
                    int num = scanner.nextInt();
                    queue.addCircleQueue(num);
                    break;
                case 'r':
                    try {
                        int item = queue.removeCircleQueue();
                        System.out.println("取出的数据是" + item);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'p':
                    try {
                        int head = queue.peekCircleQueue();
                        System.out.println("头部元素是" + head);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                default:
                    break;
            }
        }

    }
}

class CircleQueue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;

    public CircleQueue(int maxSize) {
        this.maxSize = maxSize;
        arr=new int[maxSize];
        front=0;//指向队列头部
        rear=0;//指向队列尾部的后一个位置
    }

    //判断数组里面的状态的两个方法
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }


    public boolean isEmpty() {
        return rear == front;
    }

    public void addCircleQueue(int num) {
        if (isFull()) {
            System.out.println("队列已满，不能在加元素");
            return;
        }
        arr[rear] = num;//因为rear的新含义时指向队尾的后一位
        rear = (rear + 1) % maxSize;
    }

    //取元素的方法
    public int removeCircleQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        int value = arr[front];
        front = (front + 1) % maxSize;//考虑取模问题
        return value;
    }

    public void showCircleQueue() {
        if (isEmpty()) {
            System.out.println("队列为空！");
            return;
        }
        //找出有效长度。
        for (int i = front; i < front+size(); i++) {
            System.out.println("\t" + arr[i % maxSize]);
        }
    }

    public int size() {
        return (rear + maxSize - front) % maxSize;
    }

    public int peekCircleQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");

        }
        return arr[front];//因为front指向的是队列头部
    }
}

总结

1，一定要分清楚front和rear的含义

队列	front代表的含义和初始值	rear代表的含义和初始值
传统队列	队首元素的前一个位置 （-1）	队尾元素（-1）
环形队列	队首元素（0）	队尾元素的后一个元素（0）

2.两种队列满状态和空状态的判断条件的区别

队列	满状态	空状态
传统队列	rear+1==maxSize	rear==front
环形队列	(rear + 1) % maxSize == front	rear==front

3.环形队列中多了一个可以判断队列中有效元素的个数的条件：

(rear + maxSize - front) % maxSize