01java数组模拟队列

最新推荐文章于 2024-05-03 00:21:20 发布
最新推荐文章于 2024-05-03 00:21:20 发布
阅读量413 收藏
点赞数
分类专栏： java数据结构与算法 文章标签： 数据结构 队列 java 数组模拟队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40790042/article/details/119743959
版权
这篇博客介绍了如何使用Java模拟数组实现队列，包括队列的概念、结构、主要功能如入队、出队，以及判断队列是否满或空的方法。博主通过创建ArrayQueue类，实现了队列的基本操作，并在主类ArrayQueueDemo中进行测试。博客最后指出当前实现的问题——队列不能复用，并预告将通过环形队列来优化这一问题。
摘要由CSDN通过智能技术生成

数组模拟队列

队列概念

队列是个有序的数组，可以使用数组和链表模拟

遵循先入先出原则
请添加图片描述
队列的组成:

由上图可以看到，一个队列的基本组成大致可以包括以下几点:

  1. front(头指针)
  2. rear(尾指针)
  3. maxSize(队列最大容量)
  4. 一个数组结构(最重要的一个，因为我们就是用数组来模拟队列)

队列拥有两个指针：front(头)和rear(尾),初始指向-1这个数

front：随数据的输出改变

rear： 随数据的输入改变

队列的功能:

队列我们可以想象成银行叫号排队，既然是排队，那么就有入队和出队这两个主要的功能，但是我们又知道，人太多的话，他还是排不下的，所以我们有一个范围的控制。根据上述内容,我们具体分析一下入队和出队的具体思路。

入队功能:

入队，即往队列中加入数据。首先需要将尾指针后移一步，再在尾指针的位置加入数据。但是在加入之前我们要判断这个队列否是满的，如果是，则给出信息，直接return。具体步骤如下：

  1. 判断队列否是满的？是，则给出信息，直接return。
  2. 尾指针后移
  3. 将数据加入到队列的尾指针位置

出队功能:

出队，即在队列中取出数据。首先需要将头指针后移一步，再返回头指针的位置数据（这里的取出并没有删除数组中的数据）。但是在取出之前我们要判断这个队列否是空的，如果是，就不能返回数据，我们可以抛出一个异常，在使用时捕获这个异常即可。具体步骤如下：

  1. 判断队列否是空的？是，则抛出一个异常，在使用时捕获这个异常。
  2. 头指针后移
  3. 将头指针数据取出

以上是主要的两个功能，下面是代码结构和代码实现。

代码结构和代码实现

1. 创建一个主类和队列类:

public class ArrayQueueDemo {
    public static void main(String[] args) {
        // 主类
    }
}

class ArrayQueue{
    // 队列类
}

2. 队列类包含的属性以及构造器实现:

class ArrayQueue{
    // 1.创建一个队列类
    private int maxSize; // 队列的最大容量
    private int front; // 头指针
    private int rear; // 尾指针
    private int[] arr; // 队列数组
    
    // 2.创建构造器,初始化数据
    // 传入一个参数,确定队列的最大容量
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1;  // 默认队列头是0,默认指向队列头前一个位置
        rear = -1; // 默认队列头是0,默认指向队列尾数据
    }
}

队列类拥有的主要功能:

class ArrayQueue{
    // 1.创建一个队列类
    private int maxSize; // 队列的最大容量
    private int front; // 头指针
    private int rear; // 尾指针
    private int[] arr; // 队列数组
    
    // 2.创建构造器,初始化数据
    // 传入一个参数,确定队列的最大容量
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1;  // 默认队列头是0,默认指向队列头前一个位置
        rear = -1; // 默认队列头是0,默认指向队列尾数据
    }
    
    // 3.判断队列是否为满
    public boolean isFull(){}

    // 4.判断队列是否为空
    public boolean isEmpty() {}

    // 5.添加队列数据
    public void addQueue(int n) {}

    // 6.取出队列数据
    public int getQueue() {}

    // 7.打印当前队列数据
    public void showQueue() {}

    // 8.显示队列的头数据是多少,不是取数据,是查数据
    public int headQueue() {}
}

3. 判断队列是否为满：

因为我们只有一个数组，并且数组大小已知，所以当尾指针指向数组最后一个位置索引的时候，就是队列满的时候。

数组第一个元素索引：0，最后一个元素索引：maxSize-1.

即队列满的条件：rear == maxSize-1

// 3.判断队列是否为满
public boolean isFull(){
    return rear == maxSize-1;
}

4. 判断队列是否为空：

我们以最开始的指针指向为例，两个指针都指向-1，并且没有元素，所以当两个指针指向的索引相等时，队列为空。

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

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

5. 添加队列数据

实现步骤：

  1. 判断队列否是满的？是，则给出信息，直接return。
  2. 尾指针后移
  3. 将数据加入到队列的尾指针位置
// 5.添加队列数据
    public void addQueue(int n) {
        // 添加数据我们要考虑到队列是否已满
        if (isFull()) {
            System.out.println("队列满,不能再加入了");
            return;
        }
        rear++; // 尾指针后移
        arr[rear] = n; // 将数据加入到队列的尾指针位置
    }

6. 取出队列数据

  1. 判断队列否是空的？是，则抛出一个异常，在使用时捕获这个异常。
  2. 头指针后移
  3. 将头指针数据取出
// 6.获取队列数据
public int getQueue() {
    if (isEmpty()) {
        // 因为这个方法具有返回值，我们不能返回一个数，这可能会有歧义
        // 这里使用异常来结束这个方法，并在调用时try-catch即可
        throw new RuntimeException("队列是空的,不能获取数据~\n");
    }
    front++; // 头指针后移
    return arr[front]; // 将头指针数据取出
}

7. 打印当前队列所有数据–辅助功能

打印所有数据我们只需要使用for循环从头指针遍历到尾指针即可，在遍历之前我们可以判断一下队列是否是空的，如果是空的，我们就没必要遍历了。直接给一个提示，并return即可。

// 7.打印当前队列所有数据
public void showQueue() {
    // 判断队列是否为空
    if (isEmpty()) {
        System.out.println("队列是空的,没有数据~");
        return;
    }
    // 从头到尾打印，即使是用过的数据也打印出来
    for (int i = 0; i < arr.length; i++) {
        // 格式化打印
        System.out.printf("arr[%d]=%d\n", i, arr[i]);
        // 普通打印
        // System.out.println("arr["+i+"]="+arr[i]);
    }
    
    /*
    	// 另一种遍历方式：只遍历队列里的数据
    	for (int i = front+1; i <= rear; i++) {
            System.out.println("arr["+i+"]="+arr[i]);
        }
    */
}

8. 显示队列的头数据–辅助功能

查看现在谁排在第一个，这个功能和取数据不一样，取数据头指针要后移，查看不需要。

实现步骤：

  1. 判断是否为空?是,则抛出异常,不返回数据.
  2. 返回arr[front+1]
// 8.显示队列的头数据是多少,不是取数据,是查数据
public int headQueue() {
    // 判断是否为空? 是,则抛出异常,不返回数据.
    if (isEmpty()) {
        throw new RuntimeException("队列是空的,不能获取数据~");
    }
    
    return arr[front + 1];
}

到这里所有功能代码就完成了，接下来我将所有代码放到一起展示。

代码整合–ArrayQueue（队列类）

// 数组模拟队列-编写ArrayQueue类
class ArrayQueue {
    // 1.编写主要属性
    private int maxSize; // 队列的最大容量
    private int front; // 头指针
    private int rear; // 尾指针
    private int[] arr; // 队列数组

    // 2.创建构造器,初始化数据
    // 传入一个参数,确定队列的最大容量
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1;  // 默认队列头是0,默认指向队列头前一个位置
        rear = -1; // 默认队列头是0,默认指向队列尾数据
    }

    // 3.判断队列是否满
    public boolean isFull() {
        return rear == maxSize - 1;
    }

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

    // 5.添加队列数据
    public void addQueue(int n) {
        // 添加数据我们要考虑到队列是否已满
        if (isFull()) {
            System.out.println("队列满,不能再加入了");
            return;
        }
        rear++;
        arr[rear] = n;
    }

    // 6.获取队列数据
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列是空的,不能获取数据~\n");
        }
        front++;
        return arr[front];
    }

    // 7.打印当前队列所有数据
    public void showQueue() {
        // 判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列是空的,没有数据~");
			return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    // 8.显示队列的头数据是多少,不是取数据,是查数据
    public int headQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列是空的,不能获取数据~");
        }
        return arr[front + 1];
    }
}

编写主类做测试

具体代码如下，比较简单，就不一 一介绍了，看注释。

package gll.queue;

import java.util.Scanner;

/**
 * 数组模拟队列-
 */
public class ArrayQueueDemo {
    public static void main(String[] args) {
        // 测试
        // 9.创建一个对象
        ArrayQueue arrayQueue = new ArrayQueue(3);
        // key当做功能按钮
        char key = ' ';
        Scanner sc = new Scanner(System.in);
        // 10.编写文字界面，flag做退出标志
        boolean flag = true;
        while (flag) {
        	// 模拟功能页面
            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 = sc.next().charAt(0);
            switch (key) {
                case 's':
                    // 查询所有数据
                    arrayQueue.showQueue();
                    break;

                case 'a':
                    // 添加数据
                    System.out.println("请输入一个数:");
                    int n = sc.nextInt();
                    arrayQueue.addQueue(n);
                    break;
                case 'g':
                    // 取出数据,有异常,需要手动抓取
                    try {
                        int result = arrayQueue.getQueue();
                        System.out.printf("取出的数据是%d\n", result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }

                    break;
                case 'h':
                    // 获取头数据,也有异常
                    try {
                        int result = arrayQueue.headQueue();
                        System.out.printf("队列的头数据是%d\n", result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    // 退出系统,这里需要将scanner关闭.并修改flag
                    sc.close();
                    flag = false;
                    System.out.println("退出系统");
                    break;
            }
        }

    }

}


// 数组模拟队列-编写ArrayQueue类
class ArrayQueue {
    // 1.编写主要属性
    private int maxSize; // 队列的最大容量
    private int front; // 头指针
    private int rear; // 尾指针
    private int[] arr; // 队列数组

    // 2.创建构造器,初始化数据
    // 传入一个参数,确定队列的最大容量
    public ArrayQueue(int arrMaxSize) {
        maxSize = arrMaxSize;
        arr = new int[maxSize];
        front = -1;  // 默认队列头是0,默认指向队列头前一个位置
        rear = -1; // 默认队列头是0,默认指向队列尾数据
    }

    // 3.判断队列是否满
    public boolean isFull() {
        return rear == maxSize - 1;
    }

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

    // 5.添加队列数据
    public void addQueue(int n) {
        // 添加数据我们要考虑到队列是否已满
        if (isFull()) {
            System.out.println("队列满,不能再加入了");
            return;
        }
        rear++;
        arr[rear] = n;
    }

    // 6.获取队列数据
    public int getQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列是空的,不能获取数据~\n");
        }
        front++;
        return arr[front];
    }

    // 7.打印当前队列所有数据
    public void showQueue() {
        // 判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列是空的,没有数据~");
			return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n", i, arr[i]);
        }
    }

    // 8.显示队列的头数据是多少,不是取数据,是查数据
    public int headQueue() {
        if (isEmpty()) {
            System.out.print("队列是空的,不能获取数据~");
            throw new RuntimeException("队列是空的,不能获取数据~");
        }
        return arr[front + 1];
    }
}

测试

测试可以自己去调一调，玩一下

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
a
请输入一个数:
10

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
s
arr[0]=10
arr[1]=0
arr[2]=0

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
a
请输入一个数:
20

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
a
请输入一个数:
30

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
s
arr[0]=10
arr[1]=20
arr[2]=30

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
a
请输入一个数:
40
队列满,不能再加入了

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
g
取出的数据是10

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
g
取出的数据是20

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
g
取出的数据是30

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
g
队列是空的,不能获取数据~

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
s
队列是空的,没有数据~

s(show):显示队列
e(exit):退出程序
a(add):添加数据到队列
g(get):从队列中取数据
h(head):查看队列头数据
e
退出系统

问题与优化

问题：队列不能复用: 上述代码还存在一些问题, 假如我的队列容量是3,那么他只能使用三次,之前使用过的位置不能重复使用,造成了浪费.数组不能复用.

解决：我们需要使用环形队列来解决。下一篇将讲述数组模拟环形队列，我们在原有的数组模拟队列基础上修改，减少工作量。

下一篇：java模拟环形队列

个人学习笔记，如有不足及时提出。

zimegll
关注
专栏目录
Java数组模拟队列
coderZ666的博客
06-09 485
队列是一种特殊的线性表，特点是先进先出。 和栈相似，它们的操作都是受限的。 队列的两种操作，插入一个数据称为入队，删除一个数据称为出队，并且只能从队尾插入数据，只能在队头删除数据。本文带大家在Java中用数组模拟实现一个队列...
Java栈和队列模拟实现及其方法使用
最新发布
2301_80873677的博客
09-06 1295
在Java中，
Java数组模拟优先级队列数据结构的实例
09-02
在上述的Java代码示例中，作者通过数组来模拟优先级队列的实现。这个模拟版本采用了类似`TreeSet`和`TreeMap`的方法，即通过比较器（Comparator）来确定元素的顺序。数组是基础，但是仅靠数组本身无法自动维护元素的...
用数组实现的优先队列（JAVA）
04-10
在Java中，我们可以使用数组来实现优先队列。这篇文章将探讨如何利用数组实现优先队列，并通过提供的`PriorityQ.java`文件来深入理解其实现原理。 1. **优先队列基本概念** 优先队列是一种数据结构，它维护了一个...
JAVA实现数组模拟队列
qq_56627079的博客
12-01 827
使用数组模拟队列
Java 实现 数组 模拟 队列
爪白白的个人博客
10-03 1531
效果图 具体实现代码 package cust.aowei.queue; import java.util.Scanner; /** * @author aoxiaobao * @project DataStruct * @date 2019/10/3 - 11:08 */ public class ArrayQueueDemo { public static void ma...
java数组模拟实现队列
qq_28840013的博客
08-11 322
转载自 尚硅谷Java数据结构与java算法，韩顺平数据结构与算法 队列介绍 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即:先存入队列的数据，要先取出。后存入的要后取出 示意图: (使用数组模拟队列示意图) 数组模拟队列思路 ➢队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图，其中maxSize 是该队列的最大容量。 ➢因为队列的输出、 输入是分别从前后端来处理，因此需要两个变量front 及rear 分别记录队列前后端的下标，front会随着数据
java学习~队列，数组模拟队列
qq_57381370的博客
03-08 436
队列：特点是先进先出。（栈是先进后出）。 这个特点是怎么完成的呢？由数组 arr[ ] 来模拟一下 数组地址是连续 所以 画个图 表示数组 ，每个格代表数组中每个元素的空间一直到数组长度减1。 0，1，2，3就是数组中元素下标。o(1)级别复杂度 （ O（1）级别复杂度：根据数组索引值访问元素；在十个元素里找和在一万个元素里边找，查找次数没有变化，查找次数是个常量。） 定义：数组最大容量 maxSize；定义头指针 front；定义尾指针 rear； 初始值 front 和 rear 先指向.
Java 队列模拟
sakuragio的博客
09-13 566
队列介绍： 队列是一个有序列表，可以用数组（顺序存储）或是链表（链式存储）来实现 遵循先进先出原则 加数据在队列尾部加，取数据在队列头部取 模拟： 队列有一个指向队首的变量，一个指向队尾的变量，一个存储数据的数组 class Queue<T> { int head; int tail; int maxSize; T [] dataArr; //...
数组模拟队列-java
m0_63267251的博客
05-03 1169
我们主要通过数组来模拟一下队列，实现基本的入队、出队、判断队空和查询队头元素的操作。
Java 数组模拟队列
莫怀疑人生
07-05 272
/* * 使用数组模拟队列 */package Queue; public class Queue { //队列类 private int maxSize; private int[] queue; private int rear; //队尾指针 private int front; //队头指针 private int num; p
java数组模拟队列
qq_43352427的博客
05-04 152
介绍： 应用场景：银行的排队系统。 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 1.数组模拟队列： 当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤： 思路分析 ①将尾指针往后移：rear+1 , 当front == rear 【空】 ②若尾指针 rear 小于队列的最大下标 maxSi...
Java通过数组模拟队列
qq_38596491的博客
03-26 253
结构： front：随着数据输出而改变 （输出：+） rear：随着数据输入而改变 （输入：+） 实现：数组或链表 数据存入队列（addQueue）的思路： 尾指针rear+1 若rear小于maxSize-1，则将数据存入rear所指的数组位置中 若rear=maxSize，则队列满 一、单队列 package queue; //数组模拟队列 public class ArrayQueu...
java数组模拟环形队列代码实现
03-13
以下是一个简单的Java数组模拟环形队列的代码实现： public class CircularQueue { private int[] queue; private int front; private int rear; private int size; public CircularQueue(int size) { this....
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值