数据结构 - 数组模拟非循环和循环队列(Java实现)

最新推荐文章于 2021-04-08 15:13:09 发布

Sun66882

最新推荐文章于 2021-04-08 15:13:09 发布

阅读量325

点赞数

分类专栏： Data Structure JavaSE

本文链接：https://blog.csdn.net/qq_42217376/article/details/106759975

版权

JavaSE 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

Data Structure

12 篇文章 1 订阅

订阅专栏

文章目录

数组模拟非循环队列
- 思路分析
- 代码实现
数组模拟循环队列
- 思路分析
- 代码实现

数组模拟非循环队列

思路分析

在这里插入图片描述

$f r o n t :$ 指向队头元素， $r e a r :$ 指向队尾元素的后面一个元素， $m a x S i z e :$ 队列大小
队列为空： $r e a r = = f r o n t$ ，队列满： $r e a r = = m a x S i z e$
进队列：直接加入到 $r e a r$ 的位置，然后 $r e a r$ 后移
出队列：记录当前 $f r o n t$ 指向的值，然后 $f r o n t$ 后移

上图可以看出队列空间大小为 $6$ ，但是这样模拟队列会有一些问题，当取出数据的时候，下面的数组的位置已经不能被使用了，当 $r e a r = 5$ 时队列已经满了，那么下面空的位置不能够被使用，此时叫做 “假溢出” 或者 “假满”，也就是数组的位置不能够被复用，我们使用循环队列就可以解决这个问题。

代码实现

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Scanner;

//数组使用一次就不能使用,没有达到复用的效果
public class ArrayQueueTest {
    public static void main(String[] args) {
        //先进先出 FIFO
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据");
            System.out.println("d(del):取出数据");
            System.out.println("t(top):查看队头");
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.print("请输入要添加的数字:");
                    int value = scanner.nextInt();
                    queue.EnQueue(value);
                    break;
                case 'd':
                    try {
                        int result = queue.DeQueue();
                        System.out.printf("取出的数据为:%d\n", result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 't':
                    try {
                        int top = queue.Top();
                        System.out.printf("队头数据为:%d\n", top);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("退出成功");
    }
}
//数组模拟队列
class ArrayQueue {
    private int maxSize; //数组最大容量
    private int front; //队尾
    private int rear; //队头
    private int[] array; //模拟队列

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        array = new int[maxSize];
        front = 0;//front指向队头
        rear = 0;//指向队尾的后一个
    }
    //判断队列是否满
    public boolean isFull() {
        return rear == maxSize;
    }
    //判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }
    //添加数据到队列
    public void EnQueue(int value) {
        if (isFull()) {
            System.out.println("队列已满,无法增加数据!");
            return;
        }
        array[rear ++] = value;
    }
    //出队列
    public int DeQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法取数据");
        }
        int value = array[front ++];
        return value;
    }
    //显示所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空,无法显示任何数据");
            return;
        }
        for (int i = front; i < rear; i++) {
            System.out.printf("array[%d] = %d\n", i, array[i]);
        }
    }
    //显示队头
    public int Top() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法显示队头");
        }
        return array[front];
    }
}

数组模拟循环队列

思路分析

循环队列：首尾相接的顺序存储结构
上面的图中我们可以发现，此时的队列的大小为 $5$ ，无论是队列满还是队列为空的时候，判断的条件都是 $f r o n t = r e a r$ ，此时我们使用的方法就是将这个循环队列预留出来一个空间，当这个环形队列中还剩一个空间时就表示这个队列已满，见下图。

按照上述策略我们就可以区别开来队列满和队列空的判断条件，只是此时数组大小为 $5$ ，队列的实际大小为 $4$ ，因为我们预留出来的一个空间。

$f r o n t :$ 指向队头元素， $r e a r :$ 指向队尾元素的后面一个元素， $m a x S i z e :$ 队列大小
队列为空： $r e a r = = f r o n t$ ，队列满： $\% maxSize==front$
进队列：直接加入到 $r e a r$ 的位置，然后 $r e a r$ 后移， $\% maxSize$
出队列：记录当前 $f r o n t$ 指向的值，然后 $f r o n t$ 后移， $\% maxSize$
队列长度：当 $r e a r > f r o n t$ 时，队列的长度为 $r e a r - f r o n t$ ，当 $r e a r < f r o n t$ 时，此时队列的长度可以分成两段，一段是 $m a x S i z e - f r o n t$ (可以想象成非循环队列的画法来模拟循环队列)，另外一段就是 $r e a r$ ，总长度为 $r e a r + m a x S i z e - f r o n t$ ，因此可以推出通用的计算的长度的公式： $\%maxSize$

代码实现

import java.util.Scanner;

public class CircleQueueTest {
    public static void main(String[] args) {
        //先进先出 FIFO
        CircleQueue queue = new CircleQueue(4);
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while (loop) {
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出程序");
            System.out.println("a(add):添加数据");
            System.out.println("d(del):取出数据");
            System.out.println("t(top):查看队头");
            key = scanner.next().charAt(0);
            switch (key) {
                case 's':
                    queue.showQueue();
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                case 'a':
                    System.out.print("请输入要添加的数字:");
                    int value = scanner.nextInt();
                    queue.EnQueue(value);
                    break;
                case 'd':
                    try {
                        int result = queue.DeQueue();
                        System.out.printf("取出的数据为:%d\n", result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 't':
                    try {
                        int top = queue.Top();
                        System.out.printf("队头数据为:%d\n", top);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                default:
                    break;
            }
        }
        System.out.println("退出成功");
    }
}

//数组模拟队列
class CircleQueue {
    private int maxSize; //数组最大容量
    private int front; //队尾
    private int rear; //队头
    private int[] array; //模拟队列

    public CircleQueue(int maxSize) {
        this.maxSize = maxSize;
        array = new int[maxSize];
        front = 0;//front指向队头
        rear = 0;//指向队尾的后一个
    }
    //判断队列是否满
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }
    //判断队列是否为空
    public boolean isEmpty() {
        return rear == front;
    }
    //添加数据到队列
    public void EnQueue(int value) {
        if (isFull()) {
            System.out.println("队列已满,无法增加数据!");
            return;
        }
        array[rear] = value;
        rear = (rear + 1) % maxSize;
    }
    //出队列
    public int DeQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法取数据");
        }
        int value = array[front];
        front = (front + 1) % maxSize;
        return value;
    }
    //显示所有数据
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列为空,无法显示任何数据");
            return;
        }
        for (int i = front; i < front + Length(); i++) {
            System.out.printf("array[%d] = %d\n", i % maxSize, array[i % maxSize]);
        }
    }
    //显示队头
    public int Top() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空,无法显示队头");
        }
        return array[front];
    }
    public int Length() {
        return (rear + maxSize - front) % maxSize;
    }
}