Java数据结构——队列与循环队列

1、队列：

队列首指针front = -1;

队列尾指针rear = -1;

队列满的条件：rear == maxSize（队列最大长度）- 1;

队列空的条件：rear == front;

队列无法重复使用，一旦队首指针后移，之前的空间便无法再次访问，效率低，空间利用率低。

2、循环队列：

循环队列是在队列的基础上进行了一些改动，使它成为了循环队列。在循环队列中加入了一个空闲空间，该空间不存任何数值，只是为了使队列成为循环队列。

队列首指针front = 0;

队列尾指针rear = 0;

队列满的条件：(rear + 1) % maxSize == front;

队列空的条件：front = rear;

package p1;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Queue q = new Queue(4);
        char key = ' ';
        boolean f = true;
        Scanner input = new Scanner(System.in);
        //输出菜单
        while (f) {
            System.out.println("s(show)显示队列");
            System.out.println("a(add)添加数据");
            System.out.println("r(remove)取出数据");
            System.out.println("h(head)查看队列头部");
            System.out.println("e(exit)退出程序");
            key = input.next().charAt(0);
            switch (key) {
                case 's':
                    q.showQueue();
                    break;
                case 'a':
                    System.out.println("请输入要添加的数据：");
                    q.addQueue(input.nextInt());
                    break;
                case 'r':
                    try {
                        int num = q.removeQueue();
                        System.out.println("取出的数据为：" + num);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        int num = q.headQueue();
                        System.out.println("队列头部数据为：" + num);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    input.close();
                    f = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }

    //数组模拟队列
    static class Queue {
        private int maxSize; //队列最大容量
        private int front; //队列头指针
        private int rear; //队列尾指针
        private int[] arr; //数组模拟队列

        public Queue(int m) {
            maxSize = m;
            arr = new int[maxSize];
            front = 0; //队首指针默认为0
            rear = 0;  //队尾指针默认为0
        }

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

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

        //添加数据
        public void addQueue(int n) {
            //判断队列是否满
            if (isFull()) {
                System.out.println("队列已满，无法添加数据");
                return;
            }
            arr[rear] = n;
            rear = (rear + 1) % maxSize; //尾指针后移，当大于数组长度时，重新循环数组
        }

        //取出数据
        public int removeQueue() {
            //判断队列是否为空
            if (isEmpty()) {
                throw new RuntimeException("队列为空，无法取出数据");
            }
            int num = arr[front];
            front = (front + 1) % maxSize; //头指针后移，当超过数组长度时，重新循环
            return num;
        }

        //显示队列
        public void showQueue() {
            if (isEmpty()) {
                System.out.println("队列空");
                return;
            }
            for (int i = front; i < front + (rear + maxSize - front) % maxSize; i++) {
                System.out.printf("%d ", arr[i % maxSize]); //当超过数组长度时，重新循环
            }
            System.out.println();
        }

        //显示队列头数据
        public int headQueue() {
            if (isEmpty()) {
                throw new RuntimeException("队列空");
            }
            return arr[front];
        }
    }
}