基于数组实现定长队列

已于 2022-04-13 10:34:57 修改
阅读量488 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java从开发到设计 文章标签： java 后端
于 2022-04-07 15:55:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dw147258dw/article/details/124018905
本文介绍了如何使用数组实现定长队列，并探讨了高级实现方式，通过缓存行填充避免伪共享，提高效率。详细分析了对象内存布局，并提出进一步优化建议，如填充对象并利用其属性，以及添加日志和事件处理来同步数据。

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

一，一般实现

有时候我们需要一个定长的队列，超过的数据会挤掉最先添加的数据

这里提供一个技术数组实现

/***
 * data format of offset+separator+operation+separator+identify+separator+key+separator+dataSerial+endMark
 *
 */
public class RaftLeaderAppendData implements FixedLengthStoreQueue{

    private Integer appendArraySize = 1024 ;

    private RaftData[] appendData ;

    private int headIndex = -1 ;
    private long headOffset ;

    public RaftLeaderAppendData(int size){
        this.appendArraySize = size;
        appendData = new RaftData[appendArraySize];
    }

    public RaftLeaderAppendData(){
        appendData = new RaftData[appendArraySize];
    }

    @Override
    public synchronized void append(RaftData raftData){
        Assert.notNull(raftData,"raft data cannot be
了解本专栏 订阅专栏 解锁全文 超级会员免费看
数据：基于数组实现数据结构
YJingLee's 优快云 Blog
10-28 319
10 基于数组实现数据结构 10 栈(Stack) 10 队列(Queue) 10 缓冲区(Pool) 10 链表(Linked List) 10 基于数组实现数据结构 很显然数组带来很大的好处，直接的好处有几点，第一它是一块完整的连续的内存而且只需要一次性分配，第二数组本身访问效率很高，第三我们可以对数组进行复制，因为数组只有一块内存，我只要把这一块的内存完整复制就可以了，而...
Java 集合框架：Java 中的双端队列 ArrayDeque 的实现
栗筝i的博客
07-22 3745
Deque 接口表示一个双端队列（Double Ended Queue），允许在队列的首尾两端操作，所以既能实现队列行为，也能实现栈行为。Deque 常用的两种实现 ArrayDeque 和 LinkedList。ArrayDeque 是 Java 集合中双端队列的数组实现，可以从两端进行插入或删除操作，当需要使用栈时，Java 已不推荐使用 Stack，而是推荐使用更高效的ArrayDeque，当需要使用队列时也可以使用 ArrayDeque。
使用定长数组实现队列
li15006474642的博客
09-06 710
使用定长数组实现队列方法很简单： 我们需要：4、 1、一个数组 2、一个能表示数组中还有多少容量的变量 3、一个能表示队首的变量 4、一个能表示队尾的变量` 入队先判断队列还有多少容量，如果容量为0表示队满，则不能在入队。如果容量不为0.则表示队列还有容量。 然后再判断入队后，队尾是不是数组的最后一个节点，如果是，入队后队尾变为0，如果不是队尾+1； 出队表示同样的道理： 如果容量为数组的大小，则表示队列中暂无数据，不能出队，如果容量小于数组则表示，队列存在数据。可以出队。 出队时判断队首是否是数组的最后一
字节跳动面试题.使用固定长度的数组实现队列
没有感情的刷题机器
04-04 309
/** * 固定长度数组实现队列 */ public class ArrayQueue { private int[] data; private int start; private int end; private int size; public ArrayQueue(int capacity) { if (capacity &...
使用数组实现固定长度的队列
fz13768884254的博客
01-25 804
使用数组实现固定长度的队列，原理简析：   代码实现：  package com.isea.brush; /** * 使用数组实现长度队列结构 * start：队首，拿取一个数，要存放的位置 * end： 队尾，新加一个元素，应该放在哪个位置，只要end到了数组的长度-1，就回到开头 * size： 队列中的元素的个数 * 用来约束start和end，只要size没有到达数组...
用数组模拟队列的实现
Bonesi的博客
09-15 214
public class ArrayQueueDemo { class ArrayQueue{ private int maxSize;//表示数组的最大容量 private int front;//队列头 private int rear;//队列尾 private int[] arr;//该数组用于存放数据，模拟队列 public ArrayQueue(int arrMaxSize){
定长数组实现队列
Tlwhisper的博客
10-29 217
定长数组实现队列 #include<iostream> #define SIZE 100; using namespace std; class Queue { private: int arr[SIZE]; int head; int tail; public: Queue() { head=0; tail=0; } bool isFull() { return (tail+1)% SIZE==head; } bool isEmpty() { retu
基于C语言实现的环形数组队列数据结构及其基本操作
03-30
内容概要：本文档详细介绍了用C语言实现的一个基于环形数组的队列数据结构。它定义了一个名为ArrayQueue的结构体来表示队列，并实现了与之相关的一系列方法，如构造函数newArrayQueue()、析构函数delArrayQueue()、...
php基于双向循环队列实现历史记录的前进后退等功能
01-20
本文实例讲述了php基于双向循环队列实现历史记录的前进后退等功能。分享给大家供大家参考。具体如下： 为实现一个记录操作历史的功能 1. 和撤销，反撤销功能类似的一个功能。（实现操作的前进后退） 2. 和discuz...
直击高频编程考点：队列知识及经典算法题总结
热门推荐
张彦峰的博客
04-09 5万+
队列知识及编程练习总结：背景知识 +队列的应用（在Spring中的应用+在其他框架中的应用+在实际开发中的应用）+相关编程练习（用队列实现栈+使用栈实现队列+设计循环队列+滑动窗口最大值 +课程表+队列的最大值+用数组实现一个队列）
使用数组实现固定长度的队列/栈
qq_40123329的博客
08-28 375
使用数组实现固定长度的队列 主要的思路是：2个指针start和end，加上一个变量cur_size 用来表示当前队列的元素个数，只要size大于数组长度就不能再入队，size小于0就不能再出队列了。 入队：移动end变量，每次让end指向队尾元素的下一个位置，每次入队只需把元素放入到end位置。如果到达数组尾部且队列没有满，让end为0，继续循环 出队：移动start变量，每次start变量...
使用数组实现固定长度的队列结构
仰望月空的博客
04-03 1960
使用数组实现固定长度的队列结构，很多人coding时，都会使用两个变量start和end作为指针，来表示队列的头和尾，然后判断end大于start，start一直追赶end的这种方式实现，这其中有些边界条件判断来判断去，end到达尾部然后回到头部，end又小于start等等情况。coding起来比较复杂。我的实现呢，再添加一个变量size，用来表示当前队列还有几个元素，只要size大于数组长度就不...
用数组结构实现大小固定的队列和栈（java）
jikuidongke5461的博客
09-29 290
栈的实现 栈的特点是先进后出，所以用数组实现栈时，只需要利用一个指针判定数据存储的位置即可，添加元素时判断指针是否超过数组长度，如果没有越界将元素添加到指针所指的位置，并将指针向下移动一位；否则返回异常，显示栈空间已满。删除元素思路类似，判断指针是否为数组初始位置，不是则将指针所指元素返回，并将指针向上。 public class ArrayStack { private Integer[] arr; private Integer index; //初始化栈 public Arra
8.用定长数组 实现 循环队列
我多么希望明天有太阳，来灼烧我腐烂的梦想
04-16 1021
// 用定长数组 实现 循环队列 #include #include #define MAXSIZE 100 typedef bool Status; #define OK 0 #define ERROR 1 typedef int QElemType; typedef struct QNode { QElemType *base; int front; int rear; }SqQueue
定长队列的C实现
hhelianthus的博客
08-25 574
以后有空就写个博客，算是技术笔记。 队列的特征是先进先出，可以满足许多应用场景需求，下面是自己用C实现的定长循环队列（代码有问题的话欢迎大家指正）。 //这个队列实现暂且定位为“单生产者单消费者模型”。 //在这个循环队列里，"队空"的条件是：队头索引 = 队尾索引, “队满”的条件是：队尾索引加1等于队头索引 //按照惯性思维，队头在左边，队尾在右边，入队是尾右移，索引值增加，出队是队...
某大厂二面编程题-用固定长度数组模拟队列实现
u012140251的博客
11-29 287
某大厂二面编程题-用固定长度数组模拟队列实现前言一、题目二、解决1.切片实现2.固定长度数组实现可能会有人说为什么结构体里的字段不大写。总结 前言 刚面完某大厂二面golang后端，面试官人很好，给我出的面试题没那么难，但刚拿到手还是很懵B的，第一反应是拿切片实现，面试官同意了。虽然有点波折，但还是用切片做出来了。过程中有了数组实现的思路，就给面试官说了，他就我的思路问了几个问题，我回答的7788。二面也让我通过了，感恩。等待HR面，期待Offer。 一、题目 要求用固定长度数组模拟队列，要求实现入队、
java之定长队列
weixin_40452750的博客
10-08 936
java固定长度的队列实现
队列（一）——队列的数组实现方式
laoniu_c的专栏
08-04 5922
1.队列的概念 队列是一种特殊的线性表，只允许在队列的一端进行插入而在另一端进行删除。 队列一般拥有队首（front指针）和队尾（rear指针），当一个队列并未存入数据的时候，front和rear指针均指向队首。 入队的操作：rear后移，存入数据在rear指向的单元，队满不可入队，这同时也表明front总是指向队首元素的前驱。 出队的操作：front后移，元素出队，队空不可出队。 注意
队列的数组（C语言）实现
云飞扬
06-03 3919
本篇博客将实现一般队列的数组结构，具体实现的操作有入队、出队、计算队列长度、判断队列是否为空、为满等。详细工程代码如下： 1.头文件Queue_Array.h #pragma once #ifndef QUEUE_ARRAY #define QUEUE_ARRAY #define NumOfQueue 20 typedef int ElementType; struct queue { int Capacity; int size; int front; int rear; Element
循环队列的实现只能定长空间吗
最新发布
06-19
<think>我们正在讨论循环队列的实现。用户想知道循环队列是否必须基于定长空间实现，以及如何实现动态扩容。根据引用[2]中的信息，循环队列有两种处理队满的方式：1.固定长度，队满则入队失败（处理简单）。2.长度不固定，队满则自动扩容（实现稍微复杂）。因此，循环队列并不必须基于定长空间实现，我们可以实现动态扩容的循环队列。下面我将详细解释循环队列的基本原理以及动态扩容的实现方式。###循环队列的基本概念循环队列是一种顺序存储结构的队列，它使用一个数组和两个指针（队头指针front和队尾指针rear）来实现。为了区分队空和队满，通常会浪费一个存储空间（即当队列中元素个数为数组长度减一时，认为队满）。-队空条件：`front==rear`-队满条件（浪费一个空间时）：`(rear+1)%capacity==front`###动态扩容的循环队列当队列满时，我们可以进行扩容操作。扩容的基本步骤：1.申请一个更大的数组（通常是原数组的2倍）。2.将原队列中的所有元素复制到新数组中。这里需要注意的是，由于循环队列在数组中可能是“环绕”的（即rear可能在front的前面），我们需要按顺序复制：从队头元素开始，直到队尾元素，按队列顺序复制到新数组的0位置开始。3.调整front和rear指针：复制后，front指向新数组的0位置，rear指向最后一个元素的下一个位置（即原队列中元素个数，因为新数组的起始位置是连续的）。4.释放原数组，将队列的数组指针指向新数组，并更新队列容量。###动态扩容循环队列的实现（C语言）下面我们使用C语言实现一个支持动态扩容的循环队列。首先，定义队列结构体（参考引用[1]）：```ctypedefstructSqQueue{int*base;//指向动态分配的数组intfront;//队头指针，指向队头元素intrear;//队尾指针，指向队尾元素的下一个位置intcapacity;//数组的总容量（注意：实际可用容量为capacity-1，因为要浪费一个空间区分队空队满。但动态扩容后，我们也可以改变策略，使用一个额外的标志或者计数来避免浪费空间？不过这里我们仍然使用浪费一个空间的方式，但注意扩容后容量变为原来的2倍，实际可用空间为2*capacity-1？实际上，我们扩容后可用空间是原来的2倍（因为新数组容量是原来的2倍，我们仍然浪费一个空间，所以实际可用空间为2*capacity-1，但这样理解不对，因为扩容后容量是新的，我们重新调整了数组，所以实际可用空间为new_capacity-1）。为了简单，我们仍然采用浪费一个空间的方式。}SqQueue,*PSqQueue;```注意：在动态扩容的实现中，我们增加了`capacity`成员来记录数组的总容量（包括浪费的那个空间）。####初始化队列```cvoidInitQueue(SqQueue*Q,intinit_capacity){Q->base=(int*)malloc(init_capacity*sizeof(int));if(!Q->base)exit(0);//分配失败Q->front=Q->rear=0;Q->capacity=init_capacity;}```####入队操作（带扩容）```c//检查队列是否已满intisFull(SqQueue*Q){return(Q->rear+1)%Q->capacity==Q->front;}//扩容操作voidexpandQueue(SqQueue*Q){intnew_capacity=Q->capacity*2;//扩容为原来的两倍int*new_base=(int*)malloc(new_capacity*sizeof(int));if(!new_base)exit(0);//将原队列中的元素复制到新数组（按顺序，从front开始到rear-1）inti=0;intj=Q->front;while(j!=Q->rear){new_base[i]=Q->base[j];j=(j+1)%Q->capacity;i++;}//复制完成后，新队列的front指向0，rear指向i（即元素个数）free(Q->base);Q->base=new_base;Q->front=0;Q->rear=i;//注意：此时队列中有i个元素，rear指向下一个插入位置（即下标i）Q->capacity=new_capacity;}//入队voidEnQueue(SqQueue*Q,intvalue){if(isFull(Q)){expandQueue(Q);}Q->base[Q->rear]=value;Q->rear=(Q->rear+1)%Q->capacity;}```####出队操作```cintDeQueue(SqQueue*Q,int*value){if(Q->front==Q->rear){return0;//队空}*value=Q->base[Q->front];Q->front=(Q->front+1)%Q->capacity;return1;}```####注意点1.在扩容时，我们按顺序将原队列中的元素复制到新数组的起始位置，这样新队列就不再是循环的（在新数组中是连续存储的），然后我们调整front为0，rear为元素个数（即最后一个元素的下一个位置）。这样，新数组的0到rear-1就是队列的所有元素，然后继续使用循环队列的规则（利用取模运算）进行入队和出队操作。2.由于扩容后数组大小改变，所以取模运算会使用新的capacity。###总结循环队列并不必须基于定长空间实现，我们可以通过动态扩容的方式来实现一个空间可扩展的循环队列。在队满时，我们进行扩容操作（通常扩容为原来的2倍），并将原队列中的元素按顺序复制到新数组中，然后调整队头和队尾指针。这种方法虽然实现稍微复杂，但提高了队列的灵活性，避免了因固定长度导致的入队失败问题。§§相关问题§§1.循环队列的动态扩容会影响时间复杂度吗？如何分析？2.除了动态扩容，还有哪些方法可以避免循环队列的空间浪费？3.循环队列与链式队列在性能和应用场景上有何不同？</think>### 循环队列的定长与动态扩容实现 循环队列**不一定必须基于定长空间**实现。根据引用[2]和引用[3]，循环队列有两种实现策略： 1. **定长空间实现**：队列容量固定，队满时入队失败（实现简单） 2. **动态扩容实现**：队满时自动扩容（实现更复杂但更实用） --- ### 一、定长空间实现（基础版） **核心特性**： - 预分配固定大小的数组 - 通过`front`和`rear`指针循环移动 - 浪费一个空间区分队空/队满（引用[2]）： - 队空条件：`front == rear` - 队满条件：`(rear + 1) % capacity == front` **结构体定义**（引用[1]）： ```c typedef struct SqQueue { int *base; // 存储空间基地址 int front; // 队头元素下标 int rear; // 队尾后一位置下标 int capacity; // 队列容量 } SqQueue; ``` **入队操作伪代码**： ```c bool EnQueue(SqQueue *Q, int value) { if ((Q->rear + 1) % Q->capacity == Q->front) return false; // 队满失败 Q->base[Q->rear] = value; Q->rear = (Q->rear + 1) % Q->capacity; return true; } ``` --- ### 二、动态扩容实现（进阶版） **核心思想**（引用[2]）： - 队满时自动扩容（通常2倍扩容） - 需处理数据迁移：将循环队列的"环绕数据"拉直存储到新数组 **扩容步骤**： 1. 申请2倍大小的新数组 2. 数据迁移（分两段复制）： - 从`front`复制到原数组末尾 - 从数组头部复制到`rear-1` 3. 重置指针：`front=0`, `rear=原元素个数` **动态入队实现**： ```c void EnQueue_Dynamic(SqQueue *Q, int value) { // 队满时扩容 if ((Q->rear + 1) % Q->capacity == Q->front) { int new_cap = Q->capacity * 2; int *new_base = (int*)malloc(new_cap * sizeof(int)); // 数据迁移 int i = 0; int j = Q->front; while (j != Q->rear) { new_base[i++] = Q->base[j]; j = (j + 1) % Q->capacity; // 循环移动 } free(Q->base); Q->base = new_base; Q->front = 0; Q->rear = i; // 指向最后一个元素的下一个位置 Q->capacity = new_cap; } // 正常入队 Q->base[Q->rear] = value; Q->rear = (Q->rear + 1) % Q->capacity; } ``` --- ### 三、两种实现对比 | **特性** | 定长实现 | 动态扩容实现 | |------------------|----------------------------|--------------------------| | 空间管理 | 固定大小 | 按需扩容（通常2倍） | | 队满处理 | 入队失败 | 自动扩容后继续入队 | | 时间复杂度 | $O(1)$ 入队/出队 | 均摊 $O(1)$ 入队 | | 空间利用率 | 浪费一个空间 | 扩容时暂有额外空间 | | 适用场景 | 内存受限环境 | 通用场景 | > **关键结论**：动态扩容通过均摊时间复杂度保证高效性。虽然单次扩容需 $O(n)$ 时间，但n次入队操作的总时间复杂度仍是 $O(n)$，均摊后每次 $O(1)$（引用[2]扩容策略）。 --- ### 四、其他避免空间浪费的方法 1. **增加计数标志**： - 添加`count`成员记录元素数量 - 队空：`count == 0` - 队满：`count == capacity` - 无需浪费空间，但增加维护成本 2. **链式循环队列**： - 每个节点动态分配内存 - 无固定容量限制，但指针占用额外空间 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值