数据结构中队列的简单分析和代码实现

最新推荐文章于 2024-08-06 21:07:10 发布
最新推荐文章于 2024-08-06 21:07:10 发布
阅读量467 收藏
点赞数 1
分类专栏： java 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaojiejie01/article/details/108172714
版权

@数据结构中的队列（以下代码为java语言）

数据结构中的队列分析与代码实现

算法和数据结构对于我们来说至关重要，那我今天想聊一下队列有问题欢迎大家讨论！@一只大狗头

队列

1.基本概念先入先出
代码实现：`package com.dog;

import java.util.Scanner;

/**

  • @Author big dog

  • Date on 2020/8/21 23:21
    */
    public class Queque2 {
    public static void main(String[] args) {
    ArrayQueque1 arrayQueque1 = new ArrayQueque1(3);
    char a = ’ ';
    Scanner scanner = new Scanner(System.in);
    boolean bool = true;
    while (bool){
    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)： 查看队列的头部”);
    a = scanner.next().charAt(0);
    switch (a){
    case ‘s’:
    arrayQueque1.showArray();
    break;

             case 'a':
             System.out.println("请输入一个数据：");
             int value = scanner.nextInt();
             arrayQueque1.addArray(value);
             break;

         case 'g':
             try {
                 int get = arrayQueque1.getArray();
                 System.out.println("取出的数据为" +get);
             }catch (Exception e){
                 System.out.println(e.getMessage());
             }
             break;

         case 'h' :
             try {
                 int res = arrayQueque1.headArray();
                 System.out.println("对列头部为" +res);

             }catch (Exception e) {
                 System.out.println(e.getMessage());
             }
             break;

         case 'e' :
             scanner.close();
             bool = false;
             System.out.println("程序已经退出······");
             break;

         default:
             break;
     }
 }

    }
    }

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

     public ArrayQueque1(int ArraymaxSize){
     maxSize = ArraymaxSize;
     arr = new int[maxSize];
     rear = -1;
     front = -1;
 }


 public boolean isFull() {
     return rear == maxSize - 1;
 }


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


 public void addArray(int n){
     if (isFull()){
         System.out.println("队列已经满了，无法加入数据");
         return;
     }
     rear ++;
     arr[rear] = n;
 }


 public int getArray(){
     if (isEmpty()) {
         throw new RuntimeException("队列为空");
     }
     front++;
     return arr[front];
 }


 public void showArray(){
     if(isEmpty()){
         System.out.println("队列为空，没有数据");
         return;
     }
     for (int i = 0; i < arr.length; i++) {
         System.out.printf("arr[%d] = %d\n",i,arr[i]);
     }
 }


 public int headArray(){
     if (isEmpty()){
         throw new RuntimeException("队列为空，没有数据");
     }
     return arr[front + 1];
 }

    }

分析：
1.运行结果
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部
s
队列为空，没有数据
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部
a
请输入一个数据：
10
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)： 查看队列的头部
a
请输入一个数据：
40
队列已经满了，无法加入数据
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)： 查看队列的头部
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)： 查看队列的头部
s
队列为空，没有数据
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部
a
请输入一个数据：
10
队列已经满了，无法加入数据
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部
`
2.从以上结果可以看出代码实现了一次队列，然而在接下来的一轮队列无法完成这个为一次队列，这并不是我们想要的结果。

代码改进（环形队列）

代码实现：`package com.dog;

import java.util.Scanner;

/**

  • @Author big dog

  • Date on 2020/8/22 17:28
    */
    public class HuanxinQueque {

    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println(“请输入队列最多要存贮多少个数据”);
    Queque03 queque03 = new Queque03(scanner.nextInt());
    char a = ’ ';
    boolean bool = true;
    while (bool) {
    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)： 查看队列的头部”);
    a = scanner.next().charAt(0);
    switch (a) {
    case ‘s’:
    queque03.showArray();
    break;

                 case 'a':
                 System.out.println("请输入一个数据：");
                 int value = scanner.nextInt();
                 queque03.addArray(value);
                 break;

             case 'g':
                 try {
                     int get = queque03.getArray();
                     System.out.println("取出的数据为" + get);
                 } catch (Exception e) {
                     System.out.println(e.getMessage());
                 }
                 break;

             case 'h':
                 try {
                     int res = queque03.headQueque();
                     System.out.println("对列头部为" + res);

                 } catch (Exception e) {
                     System.out.println(e.getMessage());
                 }
                 break;

             case 'e':
                 scanner.close();
                 bool = false;
                 System.out.println("程序已经退出······");
                 break;
             default:
                 break;
         }
     }
 }

    }

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

    public Queque03(int arrayMaxsize){
        maxSize = arrayMaxsize;
        arr = new int[maxSize];
    }

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

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

    public void addArray(int n){
        if(isFull()){
            System.out.println("改队列已经满了，无法加入数据");
            return;
        }
        arr[rear] = n;
        rear = (rear + 1)%maxSize;
    }

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

    public void showArray(){
        if(isEmpty()){
            System.out.println("队列为空，没有数据");
            return;
        }
        for (int i = front; i < getnum() + front; i++) {
            System.out.printf("arr[%d] = %d\n" , i%maxSize , arr[i%maxSize]);
        }
    }

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

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

}

分析：
1.调试结果
请输入队列最多要存贮多少个数据
4
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部
s
队列为空，没有数据
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部
a
请输入一个数据：
10
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)： 查看队列的头部
a
请输入一个数据：
40
改队列已经满了，无法加入数据
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)： 查看队列的头部
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)： 查看队列的头部
a
请输入一个数据：
20
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部
s
arr[3] = 20
s(show)： 显示队列
e(exit)： 退出程序
a(add)： 添加数据到队列
g(get)： 从队列中取出数据
h(head)： 查看队列的头部

2.分析完美的实现的队列的复用，得到了我们想要的结果！
`

xiaojiejie01
关注
专栏目录
数据结构队列代码
11-04
数据结构开始的顺序存储节点的全部寒素实现代码
《数据结构与算法分析》上的代码实现.zip
01-01
《数据结构与算法分析》是一本经典的数据结构和算法书籍，它深入浅出地介绍了各种常见数据结构（如数组、链表、栈、队列、树、图等）及其在实际问题中的应用。同时，书中详尽地分析了各种算法的效率，包括时间复杂度...
数据结构：队列Queue的实现与代码分析
weixin_30398227的博客
01-09 101
队列Queue是先进进出FIFO和后进后出LILO的。 只能从队尾放入数据，从对头删除数据。 跟Stack一样，我也写了两个版本，但是跟Stack还是有所不同的。 用List实现的队列，是没有大小限制的， 用Vector实现的队列，是有大小限制的，其实更加复制，很多地方要注意的。使用循环列表的方式来实现的。 对于List和Vector，都是使用自己实现的简单模板。Vector模板...
数据结构：队列（含源码）
最新发布
2401_86551514的博客
08-06 529
队列是一种只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出，进行插入操作的一端称为队尾，进行删除操作的一端称为队头，与栈刚好相反，栈时先进后出，队列是先进先出。队列和栈类似，都可以用链表和数组实现，不过有一点不同的是，队列用链表实现会更好一点，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低，这篇文章就用链表实现。另外了解一下，实际中我们有时还会使用一种队列叫循环队列，生产者消费者模型时可以就会使用循环队列，环形队列可以使用数组实现，也可以使用循环链表实现。
数据结构（6）队列的介绍与代码实现（c）
it_is_me_a的博客
08-19 810
更多数据结构的实现 文章目录队列的分类：顺序队列循环队列 （环形队列）循环队列的代码实现链式队列链式队列的代码实现优先级队列队列的应用 队列是一种运算受限的线性表，在队列上，插入限定在某一端进行，删除限定在另一端进行。允许插入的一端称为队尾，允许删除的一端称为队头。新插入的结点只能添加到队尾，被删除的只能是排在队头的结点。 进行插入操作的一端称为队尾（入队列） 进行删除操作的一端称为队头（出队...
数据结构：队列(Queue)的定义和它的函数们
qq_49666427的博客
11-29 1723
数据结构：队列(Queue)的定义和它的函数们 声明：队列满时:(rear+1)%maxsiz=front，少用一个存储空间，也就是数组的最后一个存数空间不用 一些规律： 1.和栈有点像，栈顶top是空的，队列的队尾指针所指也为空； 栈底是有东西的，队列的队首指针也是有东西的。 2.一般来说，队列的队首以上(包含队首)，队尾以下(不含队尾)是有数据的; 3.队首队尾每次变化都是+1的循环 队列的定义： #define MAXQSIZE 100; typedef int QElemType; typ
数据结构 队列以及Java代码实现
Heqianqian的博客
07-14 757
1. 队列队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 队尾(rear)——允许插入的一端 队头(front)——允许删除的一端 队列特点：先进先出(FIFO)结构模型：2.顺序循环队列/** * Queue * 队列的基本操作 * （1）清空队列
数据结构 队列实现 数据结构 队列实现
07-07
下面通过具体的代码实现来详细解释如何使用链表来实现队列。 ```c struct sNode { elemType data; // 存储数据值 struct sNode *next; // 指向下一个节点的指针 }; struct queueLK { struct sNode *front; // ...
数据结构C语言实现代码.zip
10-22
"严蔚敏的数据结构C语言实现代码"是一份广泛使用的资源，由著名计算机科学家严蔚敏教授编著，旨在帮助学习者理解和掌握数据结构的基本概念和实现方法。 在这个压缩包文件中，我们有两个主要的部分：`data-...
数据结构实验报告（包括线性表、栈和队列、串、二叉树、图、查找与排序算法的设计与实现）
06-09
### 数据结构实验报告知识点概述 #### 一、线性表基本运算 ...以上是对数据结构实验报告中提到的主要知识点的概述，这些知识点覆盖了数据结构的核心内容，对于理解和掌握数据结构的基础概念和实际应用具有重要的意义。
数据结构与算法分析(C语言描述)程序代码
08-01
这些源代码文件提供了对经典数据结构和算法的实际实现，对于学习C语言编程和理解数据结构与算法的内部工作原理非常有价值。通过阅读和分析这些代码，开发者可以提升自己在数据处理和算法设计方面的技能。
数据结构中循环队列的代码
05-16
数据结构中循环队列的代码。。。。。。。。。。。。。。。
队列操作代码（中文注释）
01-12
大学数据结构课程顺序表操作代码C++（中文注释）..............................................................................................................................
数据结构——顺序队列长代码实现
君陌的博客
11-22 452
此为本人在学习数据结构时将所学所想进行代码实现后所写成的代码，功能均能实现，仅供参考学习 #include <iostream> #include <iomanip> #include <assert.h> using namespace std; template <typename E>class queue{ private: void op...
数据结构——队列的C语言代码实现
AZ10000000的博客
05-05 4068
系列文章目录 数据结构——顺序表的C语言代码实现 数据结构——八种链表的C语言代码实现 数据结构——栈的C语言代码实现 文章目录系列文章目录前言一、基础知识队列的概念（queue）二、代码实现1.queue.h2.queue.c3.test.c总结 前言 主要实现链式队列。 提示：以下是本篇文章正文内容，下面案例可供参考 一、基础知识 队列的概念（queue） 援引百科： 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，
数据结构---队列的实现和个人分析
编程语言小筑
12-31 143
队列的一个显著的特征正好的和栈是相反的，它是按照先进先出（FIFO）的方式存储和检索元素，这就是说，对线插入队列的要先删除。还有就是队列是限制在两端进行插入和删除操作的线性表，允许进行存入操作的一端就叫“队尾”，允许进行删除操作的就是“对头”。当线性表中没有元素时，称为“空队“。那么，我们可以吧队列想象地理解成银行办理业务的一队人。 下面介绍顺序队列的定义和实现（以前写的代码） /*s...
数据结构自学——（4）队列的代码实现
qq_40945225的博客
06-27 219
#include<stdio.h> #include<malloc.h> typedef struct Queue { int * pBase; //数组，数组的首地址 int len; //数组长度 int front; //队首 int rear; //队尾 }QUEUE; void init_queue(QUEUE *); //初始化 bool en_queue(QUEUE *, int val); //入队 void trave
数据结构：队列的应用实现
sinb妃的博客
01-09 275
题目： 用队列求解迷宫问题的最短路径 思路： 0为迷宫通路，1无法通达 准备：先建立point存储路径点，然后建立队列，并实现入队，出队等基本操作，建立与迷宫等大的数组visited，step分别存储该点已经经过使用和到达该点时的最短步数。 实现：从起点开始，将起点放入队列，起点step[0][0]记为0，接着将该点附近不越界且可以抵达的点也放进队列，并将点处在的step记为1，visited设为...
工作队列分析
wangericac的专栏
07-25 644
 一、用法struct cpu_workqueue_struct {    spinlock_t lock;    long remove_sequence;    /* Least-recently added (next to run) */    long insert_sequence;    /* Next to add */    struc
《数据结构与算法分析》——Java实现的经典指南
接下来的第4章“栈和队列”介绍了两种线性数据结构，它们在计算机科学中有广泛应用，例如在表达式求值、深度优先搜索等场景。第5章“链表”进一步探讨了非连续存储的数据结构，链表的灵活性使其在处理动态数据集时...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值