数据结构学习（java版）——队列（Queue，高级队列）

最新推荐文章于 2024-05-18 08:11:32 发布
最新推荐文章于 2024-05-18 08:11:32 发布
阅读量168 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 队列 java 数据结构 queue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42909053/article/details/112976590
版权

普通队列

解释高级队列前，先来看普通队列出队：

在这里插入图片描述

出队之后，后边所有的元素都要往前移，时间复杂度为O(n)级别，那么，如果我们能避免往前移这个操作，时间复杂度不久是O(1)了吗？

高级队列

由此设计出了一个更高级的队列：

第一个元素被移除后，把二个元素当作队首，第二个元素被移除后，把三个元素当作队首，这样就避免了所有元素往前移的操作，但是这样前边的位置就空了，空间有浪费。

如果，后边存满，我们往前边空的位置存，这样就可以解决空间浪费问题了。这就是循环队列

怎么实现呢？

我们只需要标识一下队首和队尾不就可以实现了！

看一下图示：

入队操作

在这里插入图片描述

出队操作

在这里插入图片描述

再入队：

在这里插入图片描述

重点来了，后边存满了，咱们该往前边空的地方存了！

在这里插入图片描述
如此就实现了循环队列。

但是具体到代码实现上，你会发现我们始终都多申请了一个位置，这个位置就是用来判满的。

这样我们只需要判断 (tail + 1) % data.length == front就可以知道是否存满。

如果不留，判空、调整数组大小会变得比较复杂。感兴趣的可以自行百度。这里只讲简单实现。

代码实现

/**
 * ClassName Array
 * Description TODO 类描述：数组章节自己写的数组
 *
 * @author ZhangRenjie
 * Date  2021/1/18 22:36
 */
public class Array<E> {

    private E[] data;
    private int size;

    // 构造函数，传入数组的容量capacity构造Array
    public Array(int capacity){
        data = (E[])new Object[capacity];
        size = 0;
    }

    // 无参数的构造函数，默认数组的容量capacity=10
    public Array(){
        this(10);
    }

    // 获取数组的容量
    public int getCapacity(){
        return data.length;
    }

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

    // 返回数组是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在index索引的位置插入一个新元素e
    public void add(int index, E e){

        if(index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");
        }

        if(size == data.length) {
            resize(2 * data.length);
        }

        for(int i = size - 1; i >= index ; i --) {
            data[i + 1] = data[i];
        }
        data[index] = e;

        size ++;
    }

    // 向所有元素后添加一个新元素
    public void addLast(E e){
        add(size, e);
    }

    // 在所有元素前添加一个新元素
    public void addFirst(E e){
        add(0, e);
    }

    // 获取index索引位置的元素
    public E get(int index){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        return data[index];
    }

    public E getLast(){
        return get(size - 1);
    }

    public E getFirst(){
        return get(0);
    }

    // 修改index索引位置的元素为e
    public void set(int index, E e){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Set failed. Index is illegal.");
        }
        data[index] = e;
    }

    // 查找数组中是否有元素e
    public boolean contains(E e){
        for(int i = 0 ; i < size ; i ++){
            if(data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    public int find(E e){
        for(int i = 0 ; i < size ; i ++){
            if(data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    // 从数组中删除index位置的元素, 返回删除的元素
    public E remove(int index){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }

        E ret = data[index];
        for(int i = index + 1 ; i < size ; i ++) {
            data[i - 1] = data[i];
        }
        size --;
        data[size] = null; // loitering objects != memory leak

        if(size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }
        return ret;
    }

    // 从数组中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从数组中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从数组中删除元素e
    public void removeElement(E e){
        int index = find(e);
        if(index != -1) {
            remove(index);
        }
    }

    @Override
    public String toString(){

        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i ++){
            res.append(data[i]);
            if(i != size - 1) {
                res.append(", ");
            }
        }
        res.append(']');
        return res.toString();
    }

    // 将数组空间的容量变成newCapacity大小
    private void resize(int newCapacity){

        E[] newData = (E[])new Object[newCapacity];
        for(int i = 0 ; i < size ; i ++) {
            newData[i] = data[i];
        }
        data = newData;
    }
}

/**
 * ClassName Queue
 * Description TODO 类描述 自定义队列
 *
 * @author ZhangRenjie
 * Date  2021/1/19 9:40
 */
public interface Queue<E> {
    /**
     * Description //TODO 返回队列大小
     * @return int 队列大小
     * @author ZhangRenJie
     * @date 2021/1/19 9:42
     **/
    int getSize();
    /**
     * Description //TODO 队列是否为空
     * @return boolean 是否为空
     * @author ZhangRenJie
     * @date 2021/1/19 9:42
     **/
    boolean isEmpty();
    /**
     * Description //TODO 入队——队末添加一个元素
     * @param e 入队的元素
     * @date 2021/1/19 9:42
     **/
    void enqueue(E e);
    /**
     * Description //TODO 出队-移除并返回队首元素
     * @return E 队首元素
     * @author ZhangRenJie
     * @date 2021/1/19 9:44
     **/
    E dequeue();
    /**
     * Description //TODO 查看队首元素
     * @return E 队首元素
     * @author ZhangRenJie
     * @date 2021/1/19 9:44
     **/
    E getFront();
}

/**
 * ClassName LoopQueue
 * Description TODO 类描述：环形队列，队首和队尾连接
 *
 * @author ZhangRenjie
 * Date  2021/1/21 20:04
 */
public class LoopQueue<E> implements Queue<E> {

    private E[] data;
    private int front, tail;
    private int size;

    /**
     * 构造方法，根据传入大小生成队列
     * @param capacity 数组大小
     */
    public LoopQueue(int capacity) {
        data = (E[]) new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    /**
     * 无参构造方法，生成默认大小的队列
     */
    public LoopQueue() {
        this(10);
    }

    /**
     * 返回队列容量
     * @return
     */
    public int getCapacity() {
        return data.length - 1;
    }

    /**
     * Description //TODO 返回队列大小
     *
     * @return int 队列大小
     * @author ZhangRenJie
     * @date 2021/1/19 9:42
     **/
    @Override
    public int getSize() {
        return size;
    }

    /**
     * Description //TODO 队列是否为空
     *
     * @return boolean 是否为空
     * @author ZhangRenJie
     * @date 2021/1/19 9:42
     **/
    @Override
    public boolean isEmpty() {
        return front == tail;
    }

    /**
     * Description //TODO 入队——队末添加一个元素
     *
     * @param e 入队的元素
     * @date 2021/1/19 9:42
     **/
    @Override
    public void enqueue(E e) {
        // 判断循环队列是否存满
        if ((tail + 1) % data.length == front) {
            reSize(getCapacity() * 2);
        }
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size++;
    }

    /**
     * Description //TODO 调整循环队列容量
     * @param newCapacity 需要的容量
     * @author ZhangRenJie
     * @date 2021/1/21 21:21
     */
    private void reSize(int newCapacity) {
        E[] newData = (E[])new Object[newCapacity + 1];
        for (int i = 0; i < size; i++) {
            newData[i] = data[(i + front) % data.length];
        }
        data = newData;
        front = 0;
        tail = size;
    }

    /**
     * Description //TODO 出队-移除并返回队首元素
     *
     * @return E 队首元素
     * @author ZhangRenJie
     * @date 2021/1/19 9:44
     **/
    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("不能从空的队列中移除元素");
        }
        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size --;
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
            reSize(getCapacity() / 2);
        }
        return ret;
    }

    /**
     * Description //TODO 查看队首元素
     *
     * @return E 队首元素
     * @author ZhangRenJie
     * @date 2021/1/19 9:44
     **/
    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("不能从空的队列中移除元素");
        }
        return data[front];
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d, capacity = %d\n", size, getCapacity())).append("front [");
        for (int i = front; i != tail ; i = (i + 1) % data.length) {
            res.append(data[i]);
            if ((i + 1) % data.length != tail) {
                res.append(", ");
            }
        }
        res.append("] tail");
        return res.toString();
    }
}
我想做阿信
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java高性能队列_构建分布式秒杀系统：Disruptor高性能队列
weixin_34676828的博客
03-02 405
秒杀架构持续优化中，基于自身认知不足之处在所难免，也请大家指正，共同进步。希望可以把阻塞队列ArrayBlockingQueue这个队列替换成Disruptor，由于之前曾接触过这个东西，听说很不错，正好借此机会整合进来。简介LMAX Disruptor是一个高性能的线程间消息库。它源于LMAX对并发性，性能和非阻塞算法的研究，如今构成了Exchange基础架构的核心部分。Disruptor它是一...
Java数据结构与算法02——队列
12-21
Java中的数据结构与算法是编程领域中至关重要的概念，它们为高效地处理和组织数据提供了...对于初学者来说，从简单的数组模拟开始，逐步深入到链表、环形队列以及更高级的队列实现，是学习数据结构与算法的有效路径。
Oracle高级队列(AQ)
06-12
oracle高级队列AQ介绍，文档中主要含DB层面操作和java取值操作
Java高级特性—消息队列
weixin_30587025的博客
11-04 60
1)什么是jms 　　JMS即Java消息服务（Java Message Service）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API。 　　它便于消息系统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发， 　　翻译为Java消息服务。 2)体系架构 　　JMS由以下元素组成。 　　JMS提供者provider：连...
Java一分钟之-高级集合框架：优先队列(PriorityQueue)
最新发布
zevjay的博客
05-18 390
是一种无界优先队列，它使用堆数据结构来保证每次访问队列时，队头元素总是最小（或最大，取决于排序规则）。这意味着每次插入或删除元素后，都会自动重新调整内部结构以保持排序。
Java高级编程：堵塞队列
狙击手
06-04 402
Java并发编程：阻塞队列   　　 　　在前面我们接触的队列都是非阻塞队列，比如PriorityQueue、LinkedList（LinkedList是双向链表，它实现了Dequeue接口）。 　　使用非阻塞队列的时候有一个很大问题就是：它不会对当前线程产生阻塞，那么在面对类似消费者-生产者的模型时，就必须额外地实现同步策略以及线程间唤醒策略，这个实现起来就非常麻烦。但是有了阻塞队列就不
搞懂分布式系统27：消息队列设计精要总结之高级特性篇
Java技术江湖
07-13 1128
消息队列设计精要总结之高级特性篇 队列高级特性设计 上面都是些消息队列基本功能的实现，下面来看一些关于消息队列特性相关的内容，不管可靠投递/消息丢失与重复以及事务乃至于性能，不是每个消息队列都会照顾到，所以要依照业务的需求，来仔细衡量各种特性实现的成本，利弊，最终做出最为合理的设计。 可靠投递（最终一致性） 这是个激动人心的话题，完全不丢消息，究竟可不可能？答案是，完全可能...
图解数据结构（使用Python）——队列
12-20
【队列】是一种基本的数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。在队列中，元素的添加（入队）发生在队尾，而删除（出队）则发生在队首。与之相比，栈遵循“后进先出”（LIFO，Last In ...
基于python数据结构与算法（二）——队列
12-21
队列作为一种基本的数据结构，遵循先进先出（First In First Out, FIFO）的原则，广泛应用于各种场景，如任务调度、消息处理等。在Python中，我们可以方便地实现队列操作，本文将深入探讨Python中的队列数据结构及其...
数据结构入门——队列的实现.rar
04-02
在这个"数据结构入门——队列的实现.rar"的压缩包中，我们主要关注的是队列这一基础但重要的数据结构。队列，正如其名，模拟了现实生活中的排队现象，遵循“先进先出”（FIFO, First In First Out）原则。这意味着最...
数据结构——堆栈和队列
02-06
总的来说，这个压缩包提供了关于数据结构——堆栈和队列的C语言实现，以及额外的数字转换和字符串处理功能。这些基础知识对于理解和编写高效的计算机程序至关重要。通过学习和理解这些内容，开发者能够更好地解决...
基于Oracle_高级队列技术实现应用程序间的通信
07-30
基于Oracle_高级队列技术实现应用程序间的通信
【算法】Java 中队列的使用
每天更新大数据面经和技术
04-15 1575
  队列是一种先进先出的数据结构，在算法题中应用广泛。今天也通过几个例题来学习 Java 中队列的使用。 1.力扣225.用队列实现栈   请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类：   void push(int x) 将元素 x 压入栈顶。   int pop() 移除并返回栈顶元素。   int top() 返回栈顶元素。   boolean empty() 如果栈是空的，返回 true ；否
Oracle高级队列介绍
热门推荐
老徐的博客只有干货
02-04 1万+
原始链接：http://www.oracle-developer.net/display.php?id=411 oracle高级队列介绍 高级队列Advanced Queuing(AQ)在oracle多个版本都可得到。他是oracle原生消息软件并且在每一个版本都在加强。 这篇文章提供了一个AQ的高级概览。尤其是我们将看到如何启动一个队列并进行入列--出列操作，还有通过通知创
JAVA队列（Queue）用法附实例讲解
This_pro的博客
08-27 3019
一、功能 队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 二、声明 1、声明一个栈的写法，E表示数据类型，name是你给队列起的名字，LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。 Queue <E> name = new LinkedList<E>(); 2、实例：声明一个名为queue的Integer队列 Queue<Integer> queue = new LinkedLi
Java内置队列和高性能队列Disruptor
weixin_54828627的博客
03-01 1350
Disruptor是英国外汇交易公司LMAX开发的一个高性能队列，研发的初衷是解决内存队列的延迟问题。与Kafka、RabbitMQ用于服务间的消息队列不同，disruptor一般用于线程间消息的传递。基于Disruptor开发的系统单线程能支撑每秒600万订单。disruptor适用于多个线程之间的消息队列，作用与ArrayBlockingQueue有相似之处。
Oracle 高级队列(AQ) 与JAVA JMS
略萌的程序猿大叔的博客
11-29 7865
Oracle 高级队列AQ与JAVA JMS Oracle 高级队列是什么? 高级队列Advanced Queuing(AQ)。它是oracle原生消息软件,这篇文章提供了一个AQ的高级概览。尤其是我们将看到如何启动一个队列并进行入列--出列操作，还有通过通知创建异步出列。 用这个东西我们能做些什么?(笔者理解还不够深入 , 个人见解) 数据库监控 , 消息从数据库

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值