Java实现数据结构---队列

已于 2024-05-31 14:49:33 修改
阅读量230 收藏
点赞数 2
分类专栏： 数据结构与算法 文章标签： Java 数据结构 队列 Queue
于 2019-06-20 16:09:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxx19941220/article/details/92795481
版权

文章目录

队列的定义

队列(queue)是一种抽象的线性数据结构，是一种只能在一端插入，在另一端获取的有序线性表。队列中第一个插入的元素也是第一个获取的元素，队列的数据到达次序符合“先进先出”(First In First Out, FIFO)的思想。队列常用语说明：

  • 入队：向队列中插入元素;
  • 出队：从队列中删除一个元素;
  • 下溢：对一个空队列执行出队操作;
  • 溢出：对一个满队列执行入队操作;
    通常认为溢出和下溢是异常。

队列的模型如下：
在这里插入图片描述
一般来说，队列有数组和链表两种实现方式。

队列的实现

数组实现队列

一般数组实现

一般数组实现类：

	package com.xxliao.datastructure.linerar_list.queue.array;

/**
 * @author xxliao
 * @description: 数组实现队列
 * @date 2024/5/28 14:37
 */

public class ArrayQueue {

    //对头索引
    public int front;
    //队尾索引
    public int rear;
    //队列容量
    public int capacity;
    //容器
    public Object[] array;

    //构造方法，这里暂不验证capacity合法性
    public ArrayQueue(int capacity) {
        front= -1;
        rear = -1;
        this.capacity = capacity;
        array = new Object[capacity];
    }

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

    //判断队列是否满
    public boolean isFull() {
        //队列中元素个数（队尾索引加1） 取余 容器容量 等于front（-1，0），代表满，
        // rear 和 front 初始的时候 就是 0 % capacity == -1 ,不满
        // 开始工作后，添加元素后，front 变为了 0 
        return ((rear+1)%capacity == front);
    }

    //入队
    public void enQueue(Object data) {
        if(isFull()) {
            throw new RuntimeException("Queue is Full!");
        }
        if(isEmpty()) {
            //空队列添加
            array[++front] = data; // front 变为了 1
            rear = front;
        }else {
            //不是第一次添加,数组元素依次向后移动
            for(int i =rear+1; i>0; i--){
                array[i] = array[i-1];
            }
            array[front] = data;
            rear++;
        }
    }

    //出队
    public Object deQueue() {
        if(isEmpty()) {
            throw new RuntimeException("Queue is Empty!");
        }
        Object result = array[rear];
        array[rear--] = null;
        return result;
    }
}

测试类：

	package com.xxliao.datastructure.linerar_list.queue.array;

/**
 * @author xxliao
 * @description: 数组实现队列 测试客户端
 * @date 2024/5/28 14:38
 */

public class ArrayQueueTestClient {

    public static void main(String[] args) {
        //创建队列
        ArrayQueue arrayQueue = new ArrayQueue(5);
        //一次添加1~5,
        arrayQueue.enQueue(1);
        arrayQueue.enQueue(2);
        arrayQueue.enQueue(3);
        arrayQueue.enQueue(4);
        arrayQueue.enQueue(5);
        //arrayQueue.enQueue(6);
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        System.out.println(arrayQueue.deQueue());
        //System.out.println(arrayQueue.deQueue());
    }

}

测试结果:
在这里插入图片描述

动态数组实现

动态数组实现类：

	package com.xxliao.datastructure.linerar_list.queue.array;

/**
 * @author xxliao
 * @description: 动态数组实现队列
 * @date 2024/5/28 14:50
 */

public class DynamicArrayQueue {
    //对头索引
    public int front;
    //队尾索引
    public int rear;
    //队列容量
    public int capacity;
    //容器
    public Object[] array;
    //默认队列容量为10
    public final int DEFAULT_CAPACITY = 16;

    //构造方法，无参
    public DynamicArrayQueue() {
        front= -1;
        rear = -1;
        capacity = DEFAULT_CAPACITY;
        array = new Object[capacity];
    }

    //构造方法，有参,这里暂不验证capacity合法性
    public DynamicArrayQueue(int capacity) {
        front= -1;
        rear = -1;
        this.capacity = capacity;
        array = new Object[capacity];
    }

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

    //判断队列是否为空
    private boolean isFull() {
        //队列中元素个数（队尾索引加1） 取余 容器容量 等于 0，代表满
        return ((rear+1)%capacity == front);
    }

    //队列扩容
    private void resizeQueue() {
        capacity = capacity + (capacity >> 1);
        Object[] oldArray = array;
        array = new Object[capacity];
        for (int i = 0; i < oldArray.length; i++) {
            array[i] =  oldArray[i];
        }
    }

    //入队
    public void enQueue(Object data) {
        if(isFull()) {
            //当前队列满对，扩容
            resizeQueue();
        }
        if(isEmpty()) {
            //空队列添加
            array[++front] = data;// front -> 1
            rear = front;
        }else {
            //不是第一次添加,数组元素一次向后移动
            for(int i =rear+1; i>0; i--){
                array[i] = array[i-1];
            }
            array[front] = data;
            rear++;
        }
    }

    //出队
    public Object deQueue() {
        if(isEmpty()) {
            throw new RuntimeException("Queue is Empty!");
        }
        Object result = array[rear];
        array[rear--] = null;
        return result;
    }
}

测试类：

	package com.xxliao.datastructure.linerar_list.queue.array;

/**
 * @author xxliao
 * @description: 动态数组实现队列 测试客户端
 * @date 2024/5/28 14:52
 */

public class DynamicArrayQueueTestClient {

    public static void main(String[] args) {
        //创建队列，默认容量10
        DynamicArrayQueue arrayQueue = new DynamicArrayQueue();
        //一次添加1~17
        for (int i = 1; i <= 17; i++) {
            arrayQueue.enQueue(i);
        }
        for (int i = 1; i <= 17; i++) {
            System.out.print(arrayQueue.deQueue()+"    ");
        }
    }
}

控制台输出：
在这里插入图片描述

链表实现队列

链表实现队列 节点类

	 package com.xxliao.datastructure.linerar_list.queue.linked_list;

/**
 * @author xxliao
 * @description: 链表实现队列 节点类
 * @date 2024/5/28 12:31
 */
public class Node {

    //存储数据
    protected Object data;

    //下个节点
    public Node next;

    //构造
    public Node(Object data) {
        this.data = data;
    }

    //toString查看输出
    public String toString() {
        return "Node [data=" + data + ", next=" + next + "]";
    }
}

链表实现队列 实现类

	package com.xxliao.datastructure.linerar_list.queue.linked_list;

/**
 * @author xxliao
 * @description: 链表实现队列
 * @date 2024/5/28 14:56
 */

public class LinkedListQueue {

    //对头索引
    public Node front;
    //队尾索引
    public Node rear;
    //队列元素数量
    public int size;

    //构造方法
    public LinkedListQueue() {
        front= null;
        rear = null;
        size = 0;
    }

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

    //入队
    public void enQueue(Object data) {
        Node newNode = new Node(data);
        if(isEmpty()) {
            //空队列添加
            front = rear = newNode;
        }else {
            rear.next = newNode;
            rear = newNode;
        }
        size++;
    }

    //出队
    public Object deQueue() {
        if(isEmpty()) {
            throw new RuntimeException("Queue is Empty!");
        }
        Object result = front.data;

        if(front.next == null) {
            //只有一个元素
            front = rear = null;
        }else {
            front = front.next;
        }
        size--;
        return result;
    }

    //获取元素个数
    public int size() {
        return size;
    }
}

测试类：

	package com.xxliao.datastructure.linerar_list.queue.linked_list;

/**
 * @author xxliao
 * @description: 链表实现队列 测试客户端
 * @date 2024/5/28 14:57
 */

public class LinkedListQueueTextClient {

    public static void main(String[] args) {
        // 创建队列
        LinkedListQueue linkQueue = new LinkedListQueue();
        //一次添加1~25
        for (int i = 1; i <= 25; i++) {
            linkQueue.enQueue(i);
        }
        System.out.println("size is" + linkQueue.size);
        for (int i = 1; i <= 25; i++) {
            System.out.print(linkQueue.deQueue()+"    ");
        }
    }
}

测试结果：
在这里插入图片描述

完整代码

https://github.com/xxliao100/datastructure_algorithms.git

骑车上酒吧
关注
专栏目录
Java数据结构-队列的应用
Junds0的博客
05-07 645
第1关：用两个栈实现一个队列 本关任务：用两个栈实现一个队列。 package step1; import java.util.NoSuchElementException; import java.util.Stack; public class MyQueue<E> { private Stack<E> stk1; private Stack<E> stk2; private int flag; public MyQ
Java - 数据结构，队列
ryy1999的博客
02-25 947
普通队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(FirstIn First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头（Head/Front）双端队列：可以在对头或者队尾进行插入或者删除操作。普通队列和双端队列从上面知道双向列表可以当普通队列使用，也可以当双端队列使用，也可以当栈使用。
JAVA用数组实现队列
weixin_44341126的博客
09-18 681
JAVA用数组实现队列 1.1 思路分析 队列的操作为数据先进先出，队列如同排队的人，先来先服务，所以可以实现生产者与消费者，而不用不同步锁去线程安全问题。 1.1 实现过程分析 利用指针思维监控头(head)和尾(tail)，队列满的时候tail==n （n为数组长度） 队列空为:head＝＝tail ,操作指针来实现数据的搬迁。 package com.xiaochen.queqe; public class QueueMyself<T> { /** * 这是利用数组实现队列
java：用数组实现队列操作
qq_35367566的博客
12-09 208
package javaprogram; public class Demo { public static void main(String[] args) { Queue queue = new Queue(3); boolean b = queue.isEmpty(); System.out.println("判空："+b); System.out.println("入队...
数据结构学习之队列
最新发布
weixin_46066367的博客
08-29 373
课程链接：【【强烈推荐】深入浅出数据结构 - 顶尖程序员图文讲解 - UP主翻译校对 (已完结)】 https://www.bilibili.com/video/BV1Fv4y1f7T1/?p=17&share_source=copy_web&vd_source=a380547882bee6e5ecb87e70ac629227 ———————————————— 队列先进先出，栈先进后出。 栈的插入和弹出都必须从一端进行，称为栈顶。 列表元素的插入必须从队尾进行，元素删除必须从另外一段，即队头进行。使用数组实
java使用数组实现队列
热门推荐
morris
02-14 1万+
1.1.  队列的数据结构 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 1.2.  Java实现 QueueTest package ch04; public class QueueTe
Java数组实现队列
LZ_yuanhai的博客
09-06 1079
Java队列 Java队列的应用场景 ​ 银行排队叫号系统 队列介绍 ​ 队列是一个有序列表，可以用数组和链表来实现 ​ 队列有一个原则。即：先存入队列的数据要先取出。后存入的要后取出 数组模拟队列的思路分析 ​ 因为队列的输出、输入分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着输出而改变，而rear则是随着数据输入而改变。而MaxSize则是数组队列的大小。 ​ 创建一个数组队列的类，其中需要包含以下几个方法： ​ boolean isFull():判断
java 数组实现队列
jack_shuai的博客
08-22 151
思想：添加元素时，数组尾部添加；获取元素时从数组头部获取 package ds; public class MyArrQueue<E> { private Object[] queue; private int head; private int tail; private int size; private static final int maxSize = 1 << 30; private int capacity;
图解数据结构--使用Java
04-28
全书内容浅显易懂，利用大量且丰富的图示与范例， 详解复杂的抽象理论，从最基本的数据结构概念开始 说明，再以Java工具加以诠释阵列结构、堆栈、链表 、队列、排序、查找等重要的概念，引领读者抓住重 点轻松进入...
java实现队列数据结构代码详解
08-28
"java实现队列数据结构代码详解" 本文主要介绍了 Java 实现队列数据结构的代码详解，包括队列结构的介绍、队列实现的代码和队列的应用场景。 队列结构是一种线性结构，具有特殊的运算法则：只能在一端（队头）删除...
数据结构之队列的java实现
12-22
队列在计算机术语中使用queue，和list(排)其实是一个意思。队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先... 　下面用Java实现队列的基本功能（数组版）。 package cn.zhf.list; public class MyQueu
Java队列实现，数据结构
01-14
队列实现，数据结构作业练习参考，Java实现，环境eclipes1.8
Java数据结构-队列
Vampire的博客
04-04 1302
队列，循环队列
Java数组队列，使用数组实现队列，队列
Kuimeng 的博客
04-07 275
标准类： public class ArrayQueue{ //队列，由队尾插入元素，由队首删除元素 private int[] A; //内置数组 private int front; //头指针 private int rear; //尾指针 public ArrayQueue(int size) { this.A=new int[size]; f...
数据结构(Java)---队列
I_am_fine_的博客
02-27 1324
简述队列的使用以及一些概念
java队列数据结构_Java数据结构（队列篇）
weixin_29046035的博客
02-26 146
无序队列：package ch03Stack;public class Queue {// 数组private long[] arr;// 最大空间private int maxsize;// 有效长度private int elems;// 对头private int font;// 队尾private int end;// 构造方法public Queue(int maxsize){this....
java数据结构队列
qq_57636636的博客
04-05 1224
java 数据结构 队列
数组实现队列（java）
m0_55997161的博客
09-23 137
import java.util.Scanner; //数组模拟队列 public class Duilie { public static void main(String[] args) { ArrayQueue queue=new ArrayQueue(3); char key=' ';//接收用户输入 Scanner scanner=new Scanner(System.in); boolean loop=true; //输出一个菜单 while (loop) { .
数据结构 -- 队列(Java)
weixin_45000199的博客
07-12 336
队列 * 可用 数组 和 链表 实现 * 队列本身是有序列表，先入先出 * 队列的输出、输入：变量front与rear分别记录队列前后端下标。 * front随着数据的输出而改变，rear随着数据的输入而改变 一、[x]数组模拟队列 1. 思路分析 * 将尾指针往后移: rear+1,当front==rear 【空】· * 若尾指针rear小于队列的最大下标maxSize-1,则将数据存入rear所指的数组元素中,否则无法存入数据。rear == maxSize-1[队列满] 2.判断队列空与满的条件
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

骑车上酒吧

帮到了您，有闲钱，再打赏哦~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值