数据结构之环形队列

概述

队列是一种具有先进先出(FIFO)的数据类型,可以使用多种数据结构来实现队列:数组和链表。

简单队列的应用场景比较有限,于是那些牛人们就发明一些复杂的队列:

  • 环形队列
  • 双端队列
  • 优先队列

应用场景

  • Memory Management: The unused memory locations in the case of ordinary queues can be utilized in circular queues.
  • Traffic system: In computer controlled traffic system, circular queues are used to switch on the traffic lights one by one repeatedly as per the time set.
  • CPU Scheduling: Operating systems often maintain a queue of processes that are ready to execute or that are waiting for a particular event to occur.
  • Lock Free Queue: When high performance is required, we don’t want to use lock. Circular Queue can is the top 1 data structure for lock free queue.

一般应用于需要高效且频繁进行多线程通信传递数据的场景,例如:Linux捕包、发包等等,(Linux系统中对PACKET_RX_RINGPACKET_TX_RING的支持实质就是内核实现的一种环形队列),或者用于在进程间的异步数据传输或记录日志文件时,为解决某些特殊情况下的竞争问题提供一种免锁的方法。

分析

Circular Queue,环形缓冲区,RingBuffer,先进先出,提供对缓冲区的互斥访问,通常有一个读指针和写指针。实际环形队列在工作时有3种情况:

  1. 入队速度=出队速度
    一般情况,即入队速度和出队速度大致一样,即使某个突然时刻入队速度陡然变高或者出队速度陡然变低,都能通过队列这个缓冲区把这些数据先存起来,等到能处理的时候再处理。
    数据结构之环形队列_第1张图片
  2. 入队速度>出队速度
    队列写入的速度>读取的速度,一段时间后,队列中大多数全是写入但没读取的元素,当又一个新的元素产生时,可以把这个新元素drop掉或者放在另一个缓冲区保存起来,此时说明你需要对出队处理元素的算法或逻辑优化处理速度。
    数据结构之环形队列_第2张图片
  3. 入队速度<出队速度
    队列读取速度>写入速度,说明程序出队处理元素的速度很快,这是比较好的情况,不足之处:读取队列时可能经常会轮询队列是否有新的元素,造成cpu占用过高。
    数据结构之环形队列_第3张图片

引申

引入环形队列,为了解决什么问题??

顺序队列的假溢出问题:队列的存储空间未满,却发生溢出。比如 rear 现在虽然指向最后一个位置的下一位置,但是之前队头也删除一些元素,队头指针经历若干次的 +1 之后,遗留下很多空位置,但是顺序队列还在傻乎乎的以为再有元素入队,就溢出呢!肯定不合理。故循环队列诞生!

有两种可行的解决方法:

  1. 平移元素:把元素平移到队列的首部。效率低。否决
  2. 将新元素插入到第一个位置上,构成循环队列,入队和出队仍按先进先出的原则进行。操作效率高、空间利用率高。

使用循环队列解决假溢出问题,但引入新问题:判空。

满足front = rear条件的队列有两种情况:队列空和队列满:
数据结构之环形队列_第4张图片
数据结构之环形队列_第5张图片
解决办法:

  1. 另设一个布尔变量以区别队列的空和满;
  2. 少用一个元素的空间,约定入队前测试尾指针在循环下加 1 后是否等于头指针,若相等则认为队满;(常用)
  3. 使用一个计数器记录队列中元素的总数。

实现

C参考实现GitHub

环形队列可使用数组或链表来实现,一般很少用链表来实现,因为访问链表需要挨个遍历。

需要维护两个属性,即2个index,一个是写入index,标示当前可以写入元素的index,入队时使用。一个是读取index,标示当前可以读取元素的index,出队时使用。

另外,节点状态的切换也是一个问题,即当前节点是可读还是可写。解决方案:在队列中每个元素的头部加一个元素标示字段,标示这个元素是可读还是可写,而这个的关键就在于何时设置元素的可读可写状态,当这个元素读取完之后,要设置可写状态,当这个元素写入完成之后,要设置可读状态。

public class RingBuffer {
    /**
     * 最大总量
     */
    private final int maxSize;

    /**
     * 表示队列的第一个元素的位置,初始值默认为0
     */
    private int front;

    /**
     * 表示队列的最后一个元素的后一个位置,初始值默认为0,需要空出一个空间作为“约定”
     */
    private int rear;

    /**
     * 存放数据用的数组队列
     */
    private final int[] queueArray;

    /**
     * 初始化一个maxSize长度的数组队列。
     */
    public RingBuffer(int maxSize) {
        this.maxSize = maxSize;
        this.queueArray = new int[maxSize];
    }

    /**
     * 判断队列是否满
     */
    public boolean isFull() {
        return (rear + 1) % maxSize == front;
    }

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

    /**
     * 往队列中添加一个元素
     */
    public boolean addQueue(int element) {
        if (isFull()) {
            return false;
        }
        // 队尾后移一位
        queueArray[rear] = element;
        rear = (rear + 1) % maxSize;
        return true;
    }

    /**
     * @return 弹出&获取当前队首任务
     */
    public int takeQueue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        // 队首后移一位
        int value = queueArray[front];
        queueArray[front] = 0;
        front = (front + 1) % maxSize;
        return value;
    }

    /**
     * 显示队列里的数据
     */
    public void showQueue() {
        if (isEmpty()) {
            System.out.println("队列里没有数据");
            return;
        }
        for (int i = front; i < front + size(); i++) {
            System.out.println("当前数据顺序位数 = " + queueArray[i]);
        }
    }

    /**
     * @return 队列中有效数据个数
     */
    public int size() {
        return (rear + maxSize - front) % maxSize;
    }

	public static void main(String[] args) {
        int size = 10;
        RingBuffer ringBuffer = new RingBuffer(size);
        for (int i = 0; i < size; i++) {
            boolean success = ringBuffer.addQueue(i);
            System.out.println(success ? "插入" + i + "成功" : "插入" + i + "失败");
        }
        for (int i = 0; i < size + 1; i++) {
            if (i == size - 1) {
                int item = ringBuffer.takeQueue();
                System.out.println("取出" + item + "成功");
            }
            if (i == size) {
                int item = ringBuffer.takeQueue();
                System.out.println("取出" + item + "成功");
            }
            boolean putSuccess = ringBuffer.addQueue(i);
            // 只有在i=9和10时才会各读取一次,所以这里的插入大部分都会失败,因为前面写入一轮缓冲区已经满
            System.out.println(putSuccess ? "插入" + i + "成功" : "插入" + i + "失败");
        }
    }

}

输出:

插入0成功
插入1成功
插入2成功
插入3成功
插入4成功
插入5成功
插入6成功
插入7成功
插入8成功
插入9失败
插入0失败
插入1失败
插入2失败
插入3失败
插入4失败
插入5失败
插入6失败
插入7失败
插入8失败
取出0成功
插入9成功
取出1成功
插入10成功
Process finished with exit code 0

参考

队列的存储结构和常见操作(C语言实现)
无锁环形队列的一种高效实现
环形队列

你可能感兴趣的:(算法)