队列--环形数组实现

最新推荐文章于 2024-06-03 22:56:28 发布
最新推荐文章于 2024-06-03 22:56:28 发布
阅读量525 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60333804/article/details/133419586
版权

 具体代码可参考：https://github.com/1693905917/DataStructure.git

好处

  1. 对比普通数组，起点和终点更为自由，不用考虑数据移动

  2. “环”意味着不会存在【越界】问题

  3. 数组性能更佳

  4. 环形数组比较适合实现有界队列、RingBuffer 等

 

下标计算

例如，数组长度是 5，当前位置是 3 ，向前走 2 步，此时下标为 (3 + 2)\%5 = 0

  • cur 当前指针位置

  • step 前进步数

  • length 数组长度

注意：

  • 如果 step = 1，也就是一次走一步，可以在 >= length 时重置为 0 即可

判断空

判断该数组是否为空：头指针==尾指针

判断满

判断该数组是否满：（尾指针的索引+1）%数组长度==头指针的索引

满之后的策略可以根据业务需求决定

  • 例如我们要实现的环形队列，满之后就拒绝入队

代码：

//仅用head,tail判断空满，head,tail即为索引值
public class ArrayQueue<E> implements Queue<E>, Iterable<E>{
    
    private int head = 0;
    private int tail = 0;
    private final E[] array;
    private final int length;

    //SuppressWarnings:抑制警告
    @SuppressWarnings("all")
    public ArrayQueue(int capacity) {
        //你设定的容量+1：在你添加满容量时，需要有多出一个的位置给尾指针
        length = capacity + 1;
        array = (E[]) new Object[length];
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        array[tail] = value;
        //当加到数组最大索引位置时，应该让tail=数组初始索引位置0
        tail = (tail + 1) % length;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head];
        //当加到数组最大索引位置时，应该让tail=数组初始索引位置0
        head = (head + 1) % length;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return array[head];
    }

    @Override
    public boolean isEmpty() {
        return tail == head;
    }

    @Override
    public boolean isFull() {
        return (tail + 1) % length == head;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public E next() {
                E value = array[p];
                p = (p + 1) % array.length;
                return value;
            }
        };
    }
}

判断空、满方法2

//修改在数组满的时候，不用给尾指针留个位置

引入 size

public class ArrayQueue2<E> implements Queue<E>, Iterable<E> {

    private int head = 0;
    private int tail = 0;
    private final E[] array;
    private final int capacity;
    private int size = 0;

    @SuppressWarnings("all")
    public ArrayQueue2(int capacity) {
        this.capacity = capacity;
        array = (E[]) new Object[capacity];
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        array[tail] = value;
        tail = (tail + 1) % capacity;
        size++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head];
        head = (head + 1) % capacity;
        size--;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return array[head];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == capacity;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;

            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public E next() {
                E value = array[p];
                p = (p + 1) % capacity;
                return value;
            }
        };
    }
}

判断空、满方法3

  • head 和 tail 不断递增，用到索引时，再用它们进行计算，两个问题

    • 如何保证 head 和 tail 自增超过正整数最大值的正确性

    • 如何让取模运算性能更高

  • 答案：让 capacity 为 2 的幂

public class ArrayQueue3<E> implements Queue<E>, Iterable<E> {

    private int head = 0;
    private int tail = 0;
    private final E[] array;
    private final int capacity;

    @SuppressWarnings("all")
    public ArrayQueue3(int capacity) {
        if ((capacity & capacity - 1) != 0) {
            throw new IllegalArgumentException("capacity 必须为 2 的幂");
        }
        this.capacity = capacity;
        array = (E[]) new Object[this.capacity];
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        array[tail & capacity - 1] = value;
        tail++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[head & capacity - 1];
        head++;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return array[head & capacity - 1];
    }

    @Override
    public boolean isEmpty() {
        return tail - head == 0;
    }

    @Override
    public boolean isFull() {
        return tail - head == capacity;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;

            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public E next() {
                E value = array[p & capacity - 1];
                
                p++;
                return value;
            }
        };
    }
}

第三个方法暴露了一个问题:因为我们的head、tail都是整型int类型，正整数的最大值int：2147483647

测试：

如果是使用C语言就会解决：unsigned int 0 ~2^32-1

对于JAVA语言，它有种方法：可以将int整型超出的时候，及时将int转换为Long类型：

Integer.toUnsignedLong(tail)

优化以后的代码：

/**
 * @BelongsProject: arithmetic
 * @BelongsPackage: com.hzp.algorithm.queue
 * @Author: ASUS
 * @CreateTime: 2023-09-25  11:26
 * @Description: TODO  环形数组实现3.0
 * @Version: 1.0
 */
//修改在数组满的时候，不用给尾指针留个位置
public class ArrayQueue3<E> implements Queue<E>, Iterable<E>{

    private int head = 0;
    private int tail = 0;
    private  E[] array;

    //SuppressWarnings:抑制警告
    @SuppressWarnings("all")
    public ArrayQueue3(int capacity) {
        array = (E[]) new Object[ capacity ];//这个时候就不需要给尾指针留个位置
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        //进行(int):数组中只能存储Int类型，不能是long类型所以要转换
        array[(int) (Integer.toUnsignedLong(tail)% array.length)] = value;
        tail++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        E value = array[(int) (Integer.toUnsignedLong(head)% array.length)];
        head++;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return array[(int) (Integer.toUnsignedLong(head)% array.length)];
    }

    @Override
    public boolean isEmpty() {
        return head==tail;
    }

    @Override
    public boolean isFull() {
        return tail-head==array.length;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p!=tail;
            }

            @Override
            public E next() {
                E value = array[(int) (Integer.toUnsignedLong(p)%array.length)];
                p++;
                return value;
            }
        };
    }
}

判断空、满方法4

我们以二进制的角度来看求模运算的规律：

//求模运算：
//          被除数是什么都无所谓
//        如果除数是2的n次方
//        那么被除数的后n位即为余数（馍）
//        求被除数的后n位方法：与2^n-1按位与

演示：

总结规律：当除数是2的n次方，则余数是被除数的二进制后n位，被除数剩余的二进制就是商的二进制

对于我们求模运算而言，我们只需要余数即可：

所以结论：求余数：被除数与2^n-1按位与即可得到余数：

//求模运算：
//        如果除数是2的n次方
//        那么被除数的后n位即为余数（馍）
//        求被除数的后n位方法：与2^n-1按位与
public class ArrayQueue3_1<E> implements Queue<E>, Iterable<E>{

    private int head = 0;
    private int tail = 0;
    private  E[] array;

    //SuppressWarnings:抑制警告
    @SuppressWarnings("all")
    //这个方法的条件就是 capacity的取值必须是2的n次方
    public ArrayQueue3_1(int capacity) {
        array = (E[]) new Object[ capacity ];//这个时候就不需要给尾指针留个位置
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        //进行(int):数组中只能存储Int类型，不能是long类型所以要转换
        //array[(int) (Integer.toUnsignedLong(tail)% array.length)] = value;
        //以下方法比以上方法的优点：1.&的运算更加优化   2.这也防止了int类型超出最大值的情况
        array[tail& (array.length-1)]=value;
        tail++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        //E value = array[(int) (Integer.toUnsignedLong(head)% array.length)];
        E value = array[head& (array.length-1)];
        head++;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        //return array[(int) (Integer.toUnsignedLong(head)% array.length)];
        return array[head& (array.length-1)];
    }

    @Override
    public boolean isEmpty() {
        return head==tail;
    }

    @Override
    public boolean isFull() {
        return tail-head==array.length;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p!=tail;
            }

            @Override
            public E next() {
                //E value = array[(int) (Integer.toUnsignedLong(p)%array.length)];
                E value = array[p& (array.length-1)];
                p++;
                return value;
            }
        };
    }
}

但是注意：这个方法的条件就是 capacity的取值必须是2的n次方！！！！

因此，这个方法是有缺陷的。

判断空、满方法5

这个方法的条件就是 capacity的取值没有限制

就是对于第四种方法的优化：

第一种优化：就是对于“当输入的数不是2的幂则跑异常”：

//1.抛异常:当输入的数不是2的幂则跑异常
if(((capacity&capacity-1)!=0)){
    throw new IllegalArgumentException("capactiy 必须是2的幂");
}

对于“capacity&capacity-1”演示：

第二种优化：将输入的数不是2的幂改成2^n

这是利用第一种结论来写：

/*
当我输入的是数是30
c=30;
2^4 == 16
2^4.？ == 30
2^5 == 32

我们要找到的是这个数最近并且大于这个数的2^n：
对于幂的获取：log2(30)==4.?  --->(int)log2(30)==4 -->(int)log2(30)+1 ==5

int c=30;
        int n= (int)(Math.log10(c-1)/Math.log10(2))+1;
        System.out.println(n);
        System.out.println(1<<n);

验证1<<n == 2^n ==将1向左移动n位就是2^n
        1           2^0
        10          2^1
        100         2^2
        1000        2^3
 */

利用第二种结论：求离c最近，比c大的2^n(方法2)

c=30;
c -= 1;
c |= c >> 1;
c |= c >> 2;
c |= c >> 4;
c |= c >> 8;
c |= c >> 16;
c += 1;

代码：

public class ArrayQueue3_2<E> implements Queue<E>, Iterable<E>{

    private int head = 0;
    private int tail = 0;
    private  E[] array;

    //SuppressWarnings:抑制警告
    @SuppressWarnings("all")
    public ArrayQueue3_2(int capacity) {
        //1.抛异常:当输入的数不是2的幂则跑异常
        if(((capacity&capacity-1)!=0)){
            throw new IllegalArgumentException("capactiy 必须是2的幂");
        }
        //2.将输入的数不是2的幂改成2^n 
        capacity -= 1;
        capacity |= capacity >> 1;
        capacity |= capacity >> 2;
        capacity |= capacity >> 4;
        capacity |= capacity >> 8;
        capacity |= capacity >> 16;
        capacity += 1;
        array = (E[]) new Object[ capacity ];//这个时候就不需要给尾指针留个位置
    }

    @Override
    public boolean offer(E value) {
        if (isFull()) {
            return false;
        }
        //进行(int):数组中只能存储Int类型，不能是long类型所以要转换
        //array[(int) (Integer.toUnsignedLong(tail)% array.length)] = value;
        //以下方法比以上方法的优点：1.&的运算更加优化   2.这也防止了int类型超出最大值的情况
        array[tail& (array.length-1)]=value;
        tail++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        //E value = array[(int) (Integer.toUnsignedLong(head)% array.length)];
        E value = array[head& (array.length-1)];
        head++;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        //return array[(int) (Integer.toUnsignedLong(head)% array.length)];
        return array[head& (array.length-1)];
    }

    @Override
    public boolean isEmpty() {
        return head==tail;
    }

    @Override
    public boolean isFull() {
        return tail-head==array.length;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p = head;
            @Override
            public boolean hasNext() {
                return p!=tail;
            }

            @Override
            public E next() {
                //E value = array[(int) (Integer.toUnsignedLong(p)%array.length)];
                E value = array[p& (array.length-1)];
                p++;
                return value;
            }
        };
    }
}

CodeCoffee:
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言环形数组实现(亲测可用)
萧海的博客
06-01 652
【代码】c语言环形数组实现(亲测可用)
环形数组
weixin_47027644的博客
03-15 1197
队列是一个有序列表，可以用数组存储（顺序存储）或者链表存储（链式存储），队列一定要遵循先入先出的原则。 数组实现： public class ArrayQueueDemo { public static void main(String[] args) { //测试,初始化对象 ArrayQueue arrayQueue = new ArrayQueue(3); String key = " ";//用户输入 Scanner
同步队列-无锁队列-循环数组无锁队列.zip
05-14
配套代码讲解：https://blog.csdn.net/songchuwang1868/article/details/90200251 配套代码讲解：https://blog.csdn.net/songchuwang1868/article/details/90200251 配套代码讲解：https://blog.csdn.net/songchuwang1868/article/details/90200251 同步队列-无锁队列-循环数组无锁队列 同步队列-无锁队列-循环数组无锁队列 同步队列-无锁队列-循环数组无锁队列
手把手带你实现一个环形数组
m0_62388538的博客
04-20 396
数据结构与算法，环形数组
题解/算法 {3805. 环形数组}
最新发布
qq_66485519的博客
06-03 356
1
C语言之队列，环形数组-比链表容易多了
GKoSon的博客
07-10 6110
环形队列实现 ①定义一个结构体：typedef struct{    u16 Head;              u16 Tail;    u16 Lenght;    u8 Ring_Buff[RINGBUFF_LEN];}RingBuff_t;RingBuff_t ringBuff;//创建一个ringBuff的缓冲区②初始化结构体相关信息：使得我们的环形缓冲区是头尾相连的，并且里面没有数...
STM32使用环形数组接收不定长数据
mochen_32的博客
02-27 2253
一、环形数组的引入 在C语言单片机编程过程中，经常使用串口接收数据，采用的方式一般有两种，第一种是轮循模式接收，这种方式往往需要消耗大量的时间检测接收的数据缓存（数据），有数据的时候就执行，没有的话就退出。此外，由于串口接收数据的时刻是无法预测的，所以即使检测到数据，有时候也会由于数据丢失造成错误。还有一种是中断，中断接收响应快，但是对于不定长数据就很难办了。那么对于以上情况，本次介绍一下环形数组...
C语言环形buffer
lovegrail的博客
07-25 2929
C语言环形数组 这是一个循环缓冲区，终于写完了，指针指来指取还是很麻烦的，稍微不注意就出错了 但是思路还是挺简单的，不过对于小白的我还是用了蛮久的时间的，关键是开始没有构思好 所以出了很多问题，这是最终版本，以后希望对自己有用，今天是2019.7.25 大吉大利的晚上，各位加油 头文件 #include<stdio.h> #include <string.h> ...
环形数组（ringbuffer）
小小东西的博客
11-19 7284
一：环形数组 1、概念 **百度百科：**是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流 **个人理解：**本身就是一个定长数组，在存储数据时，达到存储上限时会从0继续存储，也就是他在存储数据时是个闭环的过程，举个例子：如下图，假设是个 大小为9字节的数组，当存满了9个字节的数据时，在存入字节时就会从0开始存储，环形数组也称ringbuffer 2、优势 首先是一个先进先出的队列，当取走数据时不需要移动数组中的其他元素，在单消费者单生产者的模型下，不需要加锁，可以更快的存取数据。
c语言数据结构实现-数组队列/环形队列
staticnetwind的专栏
12-15 6261
队列的数据结构其实非常简单，实现方式主要为动态的链式结构或者为静态的数组结构，本文介绍一种静态的数组结构 使用数组队列类似于牺牲空间换时间的方法，实现简单。但要求用户数据必须定长，并且会出现队列满的情况； 但是在索引方面，由于使用了下标法进行定位，可以快速地查找到下一个元素（head=(head + 1)&mask），这个时候也必须保证队列大小为2^N； 同时在一个生产者一个消费者的场景下，使用该队列可以无需上锁，节省锁的开销；
游戏筑基开发之环形数组（C语言）
田螺姑娘的博客
07-10 963
C语言环形数组 环形数组具有较低的时间复杂度的同时，充分利用数组的特性。 在游戏中的应用场景主要是当玩家对某一游戏操作反悔的时候，有回退（反悔）功能的时候需要使用数组。（在此处暂且不考虑指针及链表） 下面给出示例代码，代码较为精简，可供借鉴。主要使用一维数组以及conio.h库中的_getch()函数进行演示。 关于conio.h库中的_getch()，大家可以参考以下描述： _getche及其相关函数简述【点击跳转】 效果图如下： 核心思想： 代码如下： #include <stdio.h&gt
队列——数组实现
热门推荐
yangwenxiao123456的博客
08-14 1万+
队列是一种先进先出的思想。（First In First Out) 关于队列的定义就不叙述了，百度比我讲的详尽的多，在这里说一下用数组实现队列的思想，并附上代码。 我们身边的与队列相关实例很多，火车站排队买票或是买饭是排队，都是队列。因此我们很容易想到，队列是有一个头一个尾的，新来的总是在尾，最先来的总是最先买票或是吃饭，当然，像插队一类的我们不做考虑，相信我们都不会喜欢这些的。 队列的成员...
数组模拟环形队列
weixin_50125130的博客
04-12 104
队列和环形队列的相关概念 队列是数据结构的一种类型，主要特点：先进先出 先进先出：好比如排队买奶茶 先来得人肯定比后来的早点买到奶茶 2.环形队列是特殊队列的一种，特点能重复使用，像环形一样；普通队列取数据是前面的空间闲置不能利用，环形队列很好的解决这个问题 ###创建环形队列类 public class ArrayQueue{ //size表示 队列的大小 int size; //front 表示指向环形队列**首元素元素** int front; //rear 表示指向
java数组实现队列及环形队列实现过程解析
08-25
Java数组实现队列及环形队列实现过程解析 Java数组实现队列是使用Java语言中数组来模拟队列的实现过程。队列是一种重要的数据结构，广泛应用于计算机科学和软件开发中。在Java中，可以使用数组来模拟队列的实现。 ...
基于C语言的环形数组的实现.zip
05-13
在C语言中，实现环形数组可以帮助我们高效地处理数据，尤其是在需要进行循环队列、缓冲区或者固定大小的历史记录等功能时。下面我们将深入探讨环形数组的概念、优点、以及如何在C语言中实现。 1. **环形数组概念** ...
C语言数组-C语言实现使用静态数组实现循环队列.zip
03-02
循环队列的基本思想是利用数组的“环形”特性，使得队列的尾部和头部可以在数组的末尾相遇，形成一个循环。在循环队列中，我们需要两个指针：front（队头）和rear（队尾）。当front指向队列的第一个元素，rear指向...
环形数组CircleBuffer.zip
05-13
环形数组，也被称为循环数组，是一种特殊的数据结构，它在计算机科学中有着广泛的应用，尤其是在数据缓存、队列实现、以及实时系统等领域。环形数组的基本思想是将一个一维数组视为一个首尾相接的环，使得最后一个...
环形数组以及高效环形数组的qt实现
jijie_ming的博客
05-04 602
8. 由于head和tail的移动是循环的,因此可以一直追加和取出数据,实现循环利用数组空间。所以,环形数组是实现高性能循环缓冲区或队列的一种非常理想的结构,这也是spdlog选用它来实现日志缓冲的主要原因。7. 取出数据时,从head指针位置取数据,然后head指针移动。2. 使用两个指针来表示环形数组中数据的首尾,分别是head指针和tail指针。3. head指针指向环形数组的首部数据,tail指针指向环形数组的尾部数据。4. 数组中从head指针到tail指针的数据是有效数据,其余为空闲空间。
环形队列的原理介绍及其代码实现
qq_39329062的博客
06-04 2490
环形队列的这种数据结构，应用在很多框架的底层，高效简洁
数组模拟环形队列代码实现
03-13
以下是一个简单的数组模拟环形队列的代码实现： ``` #define MAXSIZE 100 // 队列的最大长度 typedef struct { int data[MAXSIZE]; // 存储队列元素的数组 int front; // 队头指针 int rear; // 队尾指针 } CircularQueue; // 初始化队列 void InitQueue(CircularQueue *q) { q->front = q->rear = 0; } // 判断队列是否为空 int IsEmpty(CircularQueue *q) { return q->front == q->rear; } // 判断队列是否已满 int IsFull(CircularQueue *q) { return (q->rear + 1) % MAXSIZE == q->front; } // 入队操作 int EnQueue(CircularQueue *q, int x) { if (IsFull(q)) { return 0; // 队列已满，入队失败 } q->data[q->rear] = x; q->rear = (q->rear + 1) % MAXSIZE; // 队尾指针后移 return 1; // 入队成功 } // 出队操作 int DeQueue(CircularQueue *q, int *x) { if (IsEmpty(q)) { return 0; // 队列为空，出队失败 } *x = q->data[q->front]; q->front = (q->front + 1) % MAXSIZE; // 队头指针后移 return 1; // 出队成功 } ``` 希望能对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值