使用数组实现队列

最新推荐文章于 2025-02-20 17:02:54 发布
最新推荐文章于 2025-02-20 17:02:54 发布
阅读量933 收藏
点赞数
分类专栏： 数据结构 java 文章标签： 数组实现队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_27293643/article/details/102723004
版权
本文介绍了队列的先入先出原则，并展示了如何通过数组实现队列，特别提到了循环数组的应用，以解决一次性使用的问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

队列是一种有序列表，可以实现数据或链表来实现，队列遵循先入先出的原则，先存入的数据先取出，后存入的数据后取出。

队列的图形:maxSize代表数据的最大容量，front代表数组头部，rear代表数组的尾部。

1、下面直接通过代码来实现:

public static void main(String[] args) {
        //操作队列数据
        ArrayQueue queue = new ArrayQueue(3);
        Scanner scanner = new Scanner(System.in);
        char ch = ' ';
        boolean loop = true;
        while(true){
            System.out.println("请输入对应的字母操作程序");
            System.out.println("a:添加数据到队列");
            System.out.println("b:取出队列的数据");
            System.out.println("c:显示队列的所有数据");
            System.out.println("d:获取头部的数据");
            System.out.println("e:显示尾部数据");
            System.out.println("f:退出程序");
            //接收一个数据
            ch = scanner.next().charAt(0);
            switch (ch) {
            case 'a':
                System.out.println("请输入一个数:");
                int num = scanner.nextInt();
                queue.addQueue(num);
                break;
            case 'b':
                try {
                    int c = queue.getQueue();
                    System.out.println(c);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                break;
            case 'c':
                try {
                    queue.showQueue();
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                break;
            case 'd':
                try {
                    int a = queue.headQueue();
                    System.out.println(a);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                break;
            case 'e':
                try {
                    int b = queue.rearQueue();
                    System.out.println(b);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                break;
            case 'f':
                loop = false;
                break;
            default:
                break;
            }
        }
    }
}

/**
 * 创建队列的类
 * @author Administrator
 *
 */
class ArrayQueue{
    private int maxSize;//队列的容量
    private int front;//队列头
    private int rear;//队列尾
    private int[] arr;//存储队列数据的数组
    
    /**
     * 添加队列的构造器
     */
    public ArrayQueue(int maxSize){
        this.maxSize = maxSize;
        arr = new int[maxSize];
        front = 0;//队列的头部
        rear = 0;//队列尾部
    }
    
    //判断队列是否已满
    public boolean isFull(){
        
        return maxSize == front;
    }
    
    //判断队列是否为空
    public boolean isEmpty(){
        
        return front == rear;
    }
    
    //添加数据到队列
    public void addQueue(int num){
        //先判断数据是否已满
        if(isFull()){
            System.out.println("队列数据已满，咱不能添加数据~~");
            return;
        }
        arr[rear] = num;

        rear++;
    }
    
    //获取队列的数据a
    public int getQueue(){
        //先判断数据是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空，不能取数据~~");
        }
        int num = arr[front];
        front++;
        return num;
    }
    
    //显示队列的所有数据
    public void showQueue(){
        //先判断数据是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空，不能取数据~~");
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("arr[%d]=%d\n",i,arr[i]);
        }
    }
    
    //获取头部的数据
    public int headQueue(){
        //先判断数据是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空，不能取数据~~");
        }
        int b = arr[front];
        return b;
    }
    
    //获取尾部的数据
    public int rearQueue(){
        //先判断数据是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空，不能取数据~~");
        }
        int a = arr[rear-1];
        return a;
    }    

注:这种方法实现的队列不能复用，只能使用一次，下面使用循环数组来实现。

public static void main(String[] args) {
        //开始操作环形数据
        AnnularQueue queue = new AnnularQueue(4);
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while(loop){
            System.out.println("请输入对应的字母开始操作程序:");
            System.out.println("a: 添加元素");
            System.out.println("b: 取出元素");
            System.out.println("c: 取出队列的头部元素");
            System.out.println("d: 取出队列的尾部元素");
            System.out.println("e: 遍历所有的元素");
            System.out.println("f: 退出程序");
            char ch = scanner.next().charAt(0);
            switch (ch) {
            case 'a':
                    System.out.println("请输入一个数据:");
                    int num = scanner.nextInt();
                    queue.addQueue(num);
                    break;
            case 'b':
                try {
                     int b = queue.getQueue();
                    System.out.println(b);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                
                break;
            case 'c':
                try {
                     int c = queue.headQueue();
                     System.out.println(c);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                break;
            case 'd':
                try {
                    int d = queue.tailQueue();
                    System.out.println(d);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                break;
            case 'e':
                try {
                    queue.showQueue();
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                break;
            case 'f':
                scanner.close();
                loop = false;
                break;
            default:
                break;
            }
        }
    }
}


class AnnularQueue{
    private int maxSize;//队列的容量
    private int rear;//队列尾
    private int front;//队列头
    private int[] array;//存放队列的数据
    
    /**
     * 增加队列的构造方法
     */
    public AnnularQueue(int maxSize){
        this.maxSize = maxSize;
        array = new int[maxSize];
        rear = 0;//队列头默认从0开始，
        front = 0;
    }
    
    
    /**
     * 判断队列是否已满
     */
    public boolean isFull(){
        
        return (rear + 1) % maxSize == front;
    }
    
    /**
     * 判断队列是否为空
     */
    public boolean isEmpty(){
        
        return rear == front;
    }
    
    /**
     * 添加元素
     */
    public void addQueue(int num){
        //判断队列是否已满
        if(isFull()){
            System.out.println("队列已满,暂不能添加元素~~");
            return;
        }
        array[rear] = num;
        //rear需要自增，这里需要考虑的队列环形问题，需要取模操作
        rear = (rear + 1) % maxSize;
    }
    
    
    /**
     * 获取元素
     */
    public int getQueue(){
        //判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空,无法取数据~~");
        }
        int num = array[front];
        //对front自增取模操作
        front = (front + 1) % maxSize;
        return num;
    }
    
    /**
     * 遍历元素
     */
    public void showQueue(){
        //判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空,无法取数据~~");
        }
        for (int i = front; i < front + getSize(); i++) {
            System.out.printf("arr[%d] = %d\n",i % maxSize ,array[i % maxSize]);
        }
    }
    
    /**
     * 查询有效的元素
     */
    public int getSize(){
        
        return (rear + maxSize - front) % maxSize;
    }
    
    
    /**
     * 取出头部元素
     */
    public int headQueue(){
        //判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空,无法取数据~~");
        }
        return array[front];
    }
    
    /**
     * 取出尾部元素
     */
    public int tailQueue(){
        //判断队列是否为空
        if(isEmpty()){
            throw new RuntimeException("数据为空,无法取数据~~");
        }
        if(rear==0){
            rear = 4;
        }
        return array[rear-1];
    }

 

使用数组实现队列的C++编程
2301_79325339的博客
09-04 123
需要注意的是，使用数组实现的队列是有固定容量的，即在创建队列时需要指定最大容量。为了更好地利用数组空间，可以考虑使用循环队列的实现方式，但本文中的示例代码仅演示了基本的队列操作。以上方法的实现中，我们根据队列的定义和特性进行了相应的判断和操作。通过上述代码，我们成功地使用数组实现了队列的基本功能。使用数组作为底层数据结构可以有效地实现队列的入队和出队操作，并且具有较高的效率。首先，我们需要定义一个固定大小的数组来存储队列的元素。假设我们的队列最大容量为N，我们可以创建一个具有N个元素的数组。
C++使用数组实现队列详解
ByteWhiz的博客
08-23 380
在上述代码中，我们使用变量head和tail来记录队列的头和尾的位置。否则将队列的头部元素移除，并更新head变量的值。队列采用先进先出（FIFO）的原则，即先进队列的元素也先出队列。使用数组来实现队列是一种常见的方法。我们可以通过指针来记录队列的头和尾的位置，并采用循环队列的方式来保证数组的重复利用。本文介绍了如何使用数组实现队列，并提供了相应的源代码。在实际应用中，队列是一种非常重要的数据结构，能够广泛应用于计算机科学、数学和物理学等领域。队列是一种常用的数据结构，而在C++中可以使用数组实现队列。
数组实现队列
Vonzhuxi的博客
09-05 1246
队列 先进先出。insert入队列，remove出队列。数组实现有队列空，队列满。 数组实现队列 数组实现简单队列有头和尾“指针”。插入元素，队尾rear指针上移加1。移除元素，队头指针上移加1。 环绕处理（循环队列） 为了避免队列不满却不能插入数据项的情况，可以让队头队尾指针绕回到数组开始的位置，这就是循环队列（有时也称为“缓存环”）。循环队列通过nItems数据项计数字段来记录队列内元素个数，判断队列空满状态。有数据项记录数的队列，会带来一个问题，当队头队尾取一定位置时，无法判断队列状态处于空还是满。如
环形队列学习记录
Carry_bluebuff的博客
06-16 338
package com.atguigu.queue; import java.util.Scanner; /** * @author wststart * @create 2019-06-14 21:22 */ public class CircleArrayQueueDemo { public static void main(String[] args) { ...
队列(queue)
最新发布
zjy200646的博客
02-20 489
队列
利用数组实现队列操作
hulunberbus
01-11 148
利用数组实现队列操作 本文博客链接:http://blog.youkuaiyun.com/jdh99,作者:jdh,转载请注明. 说明: 项目中有30台分机,每台分机都可能发出请求,主机需要按顺序响应这些请求.这是一个FIFO先进先出的队列结构,但主机的CPU是单片机,用链表实现占用资源太多,所以尝试用数组实现. 思路: 定义1个数组,用下标表示分机号,用其中的值表示在队列中的位置. ...
一次性非环形数组队列
LuckyGuyy的博客
10-24 184
一次性非环形数组队列的显示，添加，移除操作 maxSize 数组空间 front 队列头： 指第一个元素所在位置的前一位 rear 队列尾： 指最后一个元素所在位置 package com.lucky.queue; import java.util.Scanner; /** * 非环形数组队列的显示，添加，移除操作 * @author yuanyuan.wang * */ public ...
PHP使用数组实现队列
10-28
为了使用PHP数组实现队列，我们需要掌握以下两个关键操作： 1. 入队（Enqueue）操作：向队列中添加一个新的元素。在PHP中，我们使用array_push()函数来实现入队操作。这个函数允许我们在数组的尾部添加一个或多个...
用数组实现的优先队列（JAVA）
04-10
在Java中，我们可以使用`java.util.PriorityQueue`类来实现优先队列，但这里我们关注的是用数组实现的方法。 2. **数组实现的基本思想** 数组实现优先队列的核心思想是维护一个最小堆（最小堆是堆数据结构的一种，...
利用数组实现队列（超级简单）
qq_45804132的博客
04-14 1313
数组实现队列 我们之前既然已经说过可以用链表实现队列，那么我也知道队列就是一种表，那么自然的，也可以用数组实现队列，上代码：后讲解 /*队列的数组实现*/ /*头文件*/ #include<stdio.h> #include<stdlib.h> #define error(str) fprintf(stderr,"%s",str),exit(1)//自定义报错信息 typ...
【数据结构】数组实现队列（详细版）
2301_76606232的博客
12-28 4119
队列是一种基本的数据结构，它是一种先进先出（First In First Out，FIFO）的线性结构。队列只允许在表的一端进行插入，而在另一端进行删除操作。这就相当于把数据排成一排，先插入的排在前面，后插入的排在后面，之后进行删除操作时也只能从前面依次删除。这种数据结构一般用于需要按照先后顺序进行处理的问题，如模拟系统、计算机网络中的缓存、操作系统中的进程调度等。队列的基本操作包括入队（插入元素到队尾）和出队（从队头删除元素）
队列的java实现
记忆碎片
02-26 521
和栈相反，队列是一种先进后出的数据结构 这里还是采用最简单的数组来实现和前面栈的实现比较类似，只是这里用了两个指针: 下面贴出代码： package aa; public class Queue { private Object[] data=null; private int maxSize;//队列的大小 private int front;//队头 private
基于数组实现的队列
practice
05-13 693
/** * @author qcg * @version 2019/5/13. * @description 基于数组实现的队列 * 队列的类型：顺序队列、链式队列、循环队列、阻塞队列、并发队列 */ public class MyArrayQueue { private String[] items; // 队列大小 private int size = 0; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值