Java 数据结构与算法笔记 002 数组创建的队列

笔记：用数组创建的队列

昨天忘记发了，就和今天的一起发上来了。

队列

特点

• 有序列表，可以用素组或者链表实现
• 原则是先入先出

使用数组的结构实现队列

• 创建一个类，用来模拟队列，里面需要一个数组，并设置最大容量 maxSize
• 设置两个变量 front 和 rear 分别记录队列的前后端，front 记录队列中先存入的数据的前一个位置（指向队列头部），rear 记录的是后来存入的数据（指向队列的尾部）
• 设置队列类的构造方法，获取 maxSize 的值，创建数组，初始化一些变量
• 添加队列的一些操作方法
  • 判断队列是否满了 isFull()
  • 判断队列是否为空 isEmpty()
  • 往队列中添加数据 addQueue()
  • 获取队列中的数据 getQueue()
  • 查看队列中的所有数据 showQueue()
  • 查看队列的头数据 headQueue()

例子

package com.atguigu.queue;

import java.util.Scanner;

public class Demo001 {
    public static void main(String[] args) {
        Queue queue = new Queue(3);
        Scanner scanner = new Scanner(System.in);
        char key;
        boolean loop = true;
        while(loop){
            System.out.println("s(show) : 展示列表中的全部元素");
            System.out.println("a(add) : 添加元素到列表中");
            System.out.println("g(get) : 从列表中获取元素");
            System.out.println("h(head) : 查看列表的头部元素");
            System.out.println("e(exit) : 退出系统");
            System.out.print("请输入你的操作代号：");
            key = scanner.next().charAt(0); // 这个地方老师这样写的，真的感觉很妙，能避免误按多一个键发生的错误
            switch(key){
                case 's' :
                    queue.show();
                    break;
                case 'a' :
                    System.out.print("请输入你要添加的数据（int类型）：");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g' :
                    try {
                        queue.getQueue();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        queue.headQueue();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e' :
                    loop = false;
                    break;
                default :
                    break;
            }
        }
        System.out.println("退出系统");
    }
}


// 创建一个类模拟队列
class Queue {
    // 添加一个数组，用来存储数据
    int[] arr;
    // 设置两个变量 rear 和 front 指向队列的末尾和队列头部的前一个位置
    int rear;
    int front;
    // 创建构造方法，在方法内初始化数组和 rear 、 front 的值
    public Queue(int len){
        rear = -1;
        front = -1;
        arr = new int[len];
    }
    // 创建一个判断数组是不是空的方法
    public boolean isEmpty(){
        return rear == front;
    }
    // 创建一个判断数组是不是满的方法
    public boolean isFull(){
        return rear == arr.length - 1;
    }
    // 创建一个展示所有数据的方法
    public void show(){
        if(isEmpty()){
            System.out.println("列表为空，没有数据");
        }
        for (int i = 0; i < rear - front; i++) {
            System.out.println("arr[" + i + "]" + " = " + arr[front + i + 1]);
        }
    }
    // 创建添加数据的方法
    public void addQueue(int num){
        if(isFull()){
            throw new RuntimeException("列表已满，无法添加数据");
        }
        rear++;
        arr[rear] = num;
    }
    // 创建读取数据的方法
    public int getQueue(){
        if(isEmpty()){
            throw new RuntimeException("列表已空，无法获取数据");
        }
        front++;
        return arr[front];
    }
    // 创建获取头部数据的方法
    public void headQueue(){
        if(isEmpty()){
            throw new RuntimeException("列表为空，没有头部数据");
        }
        System.out.println(arr[front + 1]);
    }
}

上面的这个例子有一个缺点，就是整个队列（数组）只能使用一次（front 和 rear 扫过数组长度个元素，），即使队列没满，在使用过一次之后也无法再进行数据的存储等操作了，这样的话其实很浪费内存空间，为了使内存空间的利用率更高，需要将其改造成环形队列，这样就能在队列没满的情况下就往里面添加元素，使内存空间的利用率更高。

改造成环形队列

改造的思路：

• front 指向队列的第一个元素，rear 指向队列的最后一个元素的下一个位置，但它们两个的初始值都为 0
• 队列满了的条件是：（ rear + maxSize） % maxSize == front
• 队列为空的条件是： rear == front
• 队列有效数据的个数：（ rear + maxSize - front ) % maxSize

例子

package com.atguigu.queue;

import java.util.Scanner;

public class CircleArrayQueueDemo {
    public static void main(String[] args) {
        CircleArray circleArray = new CircleArray(3);
        Scanner scanner = new Scanner(System.in);
        char key;
        boolean loop = true;
        while(loop){
            System.out.println("s(show) : 展示列表中的全部元素");
            System.out.println("a(add) : 添加元素到列表中");
            System.out.println("g(get) : 从列表中获取元素");
            System.out.println("h(head) : 查看列表的头部元素");
            System.out.println("e(exit) : 退出系统");
            System.out.print("请输入你的操作代号：");
            key = scanner.next().charAt(0); // 这个地方老师这样写的，真的感觉很妙，能避免误按多一个键发生的错误
            switch(key){
                case 's' :
                    try {
                        circleArray.show();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'a' :
                    System.out.print("请输入你要添加的数据（int类型）：");
                    int value = scanner.nextInt();
                    try {
                        circleArray.addQueue(value);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'g' :
                    try {
                        circleArray.getQueue();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
                        System.out.println(circleArray.headQueue());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e' :
                    loop = false;
                    break;
                default :
                    break;
            }
        }
        System.out.println("退出系统");
    }
}

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

    public CircleArray(int arrMaxSize){
        maxSize = arrMaxSize;
        arr = new int[maxSize];
    }

    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

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

    public void addQueue(int num){
        if(isFull()){
            throw new RuntimeException("列表已满，无法添加数据");
        }
        arr[rear] = num;
        rear = (rear + 1) % maxSize; // 这里妙呀，我还用 if 去判断呢
    }

    public int getQueue(){
        if(isEmpty()){
            throw new RuntimeException("列表为空，无法取出数据");
        }
        int temp = arr[front];
        front = (front + 1) % maxSize;
        return temp;
    }

    public void show(){
        if(isEmpty()){
            throw new RuntimeException("列表为空，没有数据可以展示");
        }
        for(int i = front; i < front + size(); i++){
            System.out.println("arr[" + (i % maxSize) + "] = " + arr[i % maxSize]); 
        }
    }

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

    public int headQueue(){
        if(isEmpty()){
            throw new RuntimeException("列表为空，没有头数据");
        }
        return arr[front];
    }
}

上面改造的代码最主要的区别就是 rear 和 front 的定义变动，以及为了满足循环队列的要求使用了一些简单的算法。这部分代码出现在方法的返回值以及一些条件判断之中。

今天还学了一点链表，内容的话只有一点，就不和这上面的放在一起了，等链表的内容都学了，放到一起去

---

参考资料：https://www.bilibili.com/video/BV1E4411H73v?p=14&spm_id_from=333.880.my_history.page.click