我的Java数据结构学习-3-1----队列优化（循环队列）

循环队列：

 

 

 Java代码实现：

package Demo1.Queue;

public class CircleQueueEntity {
//数组模拟的队列类

    //队列最大存储量
    private int MaxSize;

    //队列的头部
    private int front;  //指向队列的第一个元素，初始值为   0

    //队列尾部
    private int rear;//指向队列的最后一个元素的后一个位置  初始值为  0

    //队列容器--数组/存放数据空间,模拟队列
    private int[] queueArr;


    //创建队列的构造器创建
 /* 创建队列的构造器创建  alt +insert:快捷键--get，set，constructor
    Ctrl+Alt+L  格式化代码
    alt +enter  补全/提示
     Ctrl+Alt+O 优化导入的类和包
    ctrl+alt+t 选中,自动选择try-catch
     ctrl+d  复制当前行到光标后一行
     ctrl + /   单行注释
     ctrl +shift + /  多行注释   */
    public CircleQueueEntity(int maxSize) {
        MaxSize = maxSize;
        //初始化队列空间
        queueArr = new int[MaxSize];
    }


    //1.判断队列是否满
    public boolean queueIsFull() {
        //环状的队列（ 满了的话就：队尾指针和队首指针相差一个maxsize：）
        //用到了技巧：无论什么位置，队尾指针 + 1  对   maxsize   取模  == 队首指针。那就是满了
        //比如 maxsize =3，（数组下标：0，1，2）队首是 0 ，队尾那就是 2；所以判断队列满：2+1  %  3 ==  0
        //再比如  maxsize = 3 ，队首是 1  队尾那一定是 0   ，这样才maxsize   ，所以依然是：0+1  %  3==  1
        return (rear + 1) % MaxSize == front;
    }

    //2.判断队列是否为空
    public boolean queueIsNull() {
        //如果队列为空，那里面的szie就是 0 ，所以队首指针和队尾指针相等呗。
        return rear == front;
    }

    //3.添加数据到队列
    public void addToQueue(int number) {
        //判断队列是否为满
        if (queueIsFull()) {
            System.out.println("队列已经满了，不能加入数据!!");
            return;
        }
        //直接将数据加入：rear 指向队列的最后一个元素的后一个位置
        queueArr[rear] = number;
        //将rear后移，这里必须考虑环形的，所以取模
        rear = (rear + 1) % MaxSize;
    }

    //4.队列中取数据
    public int getQueueHead() {
        //判断队列是否为空，没有的话就不能取
        if (queueIsNull()) {
            //如果是空的就不能取数据
            System.out.println("队列是空的，没有数据");
            //throw new RuntimeException("队列是空的，不能取数据");
            return -1;
        }
        //front 指向队列的第一个元素，1先把front 对应的值保存到一个临时变量 用于返回，然后将front 后移
        int value = queueArr[front];
        front = (front + 1) % MaxSize;
        return value;
    }

    //5.显示所有的队列信息
    public void showQueue() {
        //遍历数组
        if (queueIsNull()) {
            System.out.println("队列是空的，没有数据");
            return;
        }
        //从 front 开始遍历，遍历到rear 前一个

        int len = dataSize();
        //front 开始，总长度：front + 队列数据个数  
        for (int i = front; i < front+len; i++) {
            //i 是循环的，可能倒回来！，所以是    i % MaxSize
            System.out.printf("Array~[%d] = %d \n", i % MaxSize, queueArr[i % MaxSize]);
        }
    }

    //6.求出当前队列有效数据的个数
    public int dataSize() {
        
        //队列有效数据个数：就是最后一个队尾和第一个队首指针之间的数
        //由于是循环队列：则 ( 队首 和 队尾之差 +Maxsize ) %Maxsize
        int value = (rear + MaxSize - front) % MaxSize;
        System.out.println("当前有效的队列个数：" + value);
        return value;
    }

    //7.显示队列的头部，不是取出数据
    public int showQueueHead() {
        if (queueIsNull()) {
            System.out.println("队列是空的，没有数据！");
            // throw new RuntimeException("队列是空的！！");
            return -1;
        }
        //front 指向第一个元素，那就是直接是队首头部。
        return queueArr[front];
    }


    public int getMaxSize() {
        return MaxSize;
    }


    public int getFront() {
        return front;
    }

    public int getRear() {
        return rear;
    }

    public int[] getQueueArr() {
        return queueArr;
    }
//删除队首数据
}

测试循环队列：

package Demo1.Queue;

import java.util.Scanner;

public class CircleQueueTest {
    public static void main(String[] args) {
        //测试
        CircleQueueEntity circleQueueEntity = new CircleQueueEntity(4);
        char key = ' ';//接收用户输入
        Scanner scanner = new Scanner(System.in);//标准输入扫描器
        boolean tag = true;//控制循环
        //输出一个菜单
        while (tag) {

            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':
                    circleQueueEntity.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数：");
                    int number = scanner.nextInt();
                    circleQueueEntity.addToQueue(number);
                    break;
                case 'g'://取出数据
                    try {
                        int result = circleQueueEntity.getQueueHead();
                        System.out.println("取出的数据：" + result);
                    } catch (Exception e) {
                        System.out.println("估计队列是空的：详细信息" + e.getMessage());
                    }
                    break;
                case 'h'://查看队列头部数据
                    try {
                        int head = circleQueueEntity.showQueueHead();
                        System.out.println("队列头部数据"+head);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    tag = false;
                    System.out.println("程序退出");
                    break;

            }
        }
    }
}