数据结构与算法(c++)——双缓存队列

“双缓存队列”是我在一次开发任务中针对特殊场景设计出来的结构。使用场景为:发送端持续向接收端发送数据包——并且不理会接收端是否完成业务逻辑。由于接收端在任何情况下停止响应即可能产生数据丢失,因此无法简单的设计一条线程安全队列来对数据写入或读取(读取数据时将队列上锁视为对写入的停止响应)。

鉴于此,我的设计思路如下:

接收端首先向A队列中写入数据,然后当数据处理请求到来的时候切换到B队列继续写入,之后将A队列中的数据交给数据处理模块,处理完成以后A队列数据清空。当下一次数据处理请求到来时,再将写入请求切换回A队列,并把B队列中的数据提交给数据处理模块再清空队列B,轮流作业。

有了思路以后,代码就比较简单了。

#include <list>

template<typename T>
class DoubleArray {

    struct NODE {
        T t;
        NODE* next;
    };
    int size_a;
    int size_b;
    NODE* header_a;
    NODE* header_a_cur;
    NODE* header_b;
    NODE* header_b_cur;
    int trigger;
public:

    DoubleArray() : size_a(0), size_b(0), trigger(0), header_a(0), header_a_cur(0), header_b(0), header_b_cur(0) {
    }

    int push(T t);
    std::list<T>& fetch(std::list<T>& list);
};

template<typename T>
int DoubleArray<T>::push(T t) {
    NODE *n = new NODE;
    n->t = t;
    n->next = 0;
    if (size_a == 0 && trigger == 0) {
        header_a = n;
        header_a_cur = n;
        size_a++;
    } else if (size_b == 0 && trigger == 1) {
        header_b = n;
        header_b_cur = n;
        size_b++;
    } else {
        switch (trigger) {
            case 0:
                header_a_cur->next = n;
                header_a_cur = n;
                size_a++;
                break;
            case 1:
                header_b_cur->next = n;
                header_b_cur = n;
                size_b++;
                break;
        }
    }
}

template<typename T>
std::list<T>& DoubleArray<T>::fetch(std::list<T>& list) {
    switch (trigger) {
        case 0:
            if (header_a != 0) {
                // change b
                trigger = 1;
                // fetch a
                NODE* temp = header_a;
                while (temp) {
                    list.push_back(temp->t);
                    temp = temp->next;
                }
                // delete a
                temp = header_a;
                for (int i = 0; i < size_a; ++i) {
                    NODE* p = temp;
                    temp = temp->next;
                    delete p;
                }
                size_a = 0;
                header_a = 0;
                header_a_cur = 0;
            }
            break;
        case 1:
            if (header_b != 0) {
                // change a
                trigger = 0;
                // fetch b
                NODE* temp = header_b;
                // delete b
                while (temp) {
                    list.push_back(temp->t);
                    temp = temp->next;
                }
                temp = header_b;
                for (int i = 0; i < size_b; ++i) {
                    NODE* p = temp;
                    temp = temp->next;
                    delete p;
                }
                size_b = 0;
                header_b = 0;
                header_b_cur = 0;
            }
            break;
    }
    return list;
}

注1:开发环境与IDE分别为CentOS 7,NetBeans 8.2

时间: 2024-10-08 07:19:30

数据结构与算法(c++)——双缓存队列的相关文章

《数据结构与算法》-3-栈和队列

目录 1. 栈 1.1 栈的基本概念 1.2 栈的顺序存储结构 1.3 栈的链式存储结构 2. 队列 2.1 队列的基本概念 2.2 队列的顺序存储结构 2.3 队列的链式存储结构 2.4 双端队列 3. 栈和队列的应用 3.1 栈在括号匹配中的应用 3.2 栈在表达式求值中的应用 3.3 栈对递归中的应用 3.4 队列在层次遍历中的应用 3.5 队列在计算机系统中的应用 4. 特殊矩阵的压缩存储 4.1 数组的定义 4.2 数组的存储结构 4.3 矩阵的压缩存储 ? 该系列博客的目的是为了学习

Java数据结构和算法之栈与队列

二.栈与队列 1.栈的定义 栈(Stack)是限制仅在表的一端进行插入和删除运算的线性表. (1)通常称插入.删除的这一端为栈顶(Top),另一端称为栈底(Bottom). (2)当表中没有元素时称为空栈. (3)栈为后进先出(Last In First Out)的线性表,简称为LIFO表. 栈的修改是按后进先出的原则进行. 每次删除(退栈)的总是当前栈中"最新"的元素,即最后插入(进栈)的元素,而最先插入的是被放在栈的底部,要到最后才能删除. 图1 [示例]元素是以a1,a2,-,a

java数据结构与算法之双链表设计与实现

转载请注明出处(万分感谢!): http://blog.csdn.net/javazejian/article/details/53047590 出自[zejian的博客] 关联文章: 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) ??上一篇文章分析顺序表和单链表,本篇就接着上篇继续聊链表,在单链表

从0开始学算法--数据结构(2.4双端队列与单调队列)

双端队列是特殊的队列,它与队列不同的是可以将元素加入头或尾,可以从头或尾取出元素(滑稽-这部就是栈和队列结合了吗). c++标准库 头文件 #include<deque> 定义 deque<int>deq; 取出队头,尾元素 deq.pop_front(); deq.pop_back(); 访问队头,尾元素 deq.front(); deq.back(); 向队头,尾加入元素 deq.push_front(x); deq.push_back(x); 单调队列是在队列的基础上使它保持

数据结构与算法系列七(队列)

1.引子 1.1.为什么要学习数据结构与算法? 有人说,数据结构与算法,计算机网络,与操作系统都一样,脱离日常开发,除了面试这辈子可能都用不到呀! 有人说,我是做业务开发的,只要熟练API,熟练框架,熟练各种中间件,写的代码不也能“飞”起来吗? 于是问题来了:为什么还要学习数据结构与算法呢? #理由一: 面试的时候,千万不要被数据结构与算法拖了后腿 #理由二: 你真的愿意做一辈子CRUD Boy吗 #理由三: 不想写出开源框架,中间件的工程师,不是好厨子 1.2.如何系统化学习数据结构与算法?

数据结构与算法(3)-----&gt;队列和栈

1. 栈和队列的基本性质 栈是先进后出;(像是子弹夹,后进先打出) 队列是先进先出;(像是平时排队买冰淇淋,按顺序轮流) 栈和队列在实现的结构上可以有数组和链表两种形式; (1)数组结构实现容易; (2)用链表结构较为复杂,因为牵扯很多的指针操作; 1.1  栈结构的基本操作 (1)pop操作;(弹出) (2)top或peek操作; (3)push操作;(压栈) (4)size操作; 1.2  队列的基本操作 (1)队列的基本操作与栈操作不同的是,push操作作为在队头加入元素;而pop操作是从

用JS描述的数据结构及算法表示——栈和队列(基础版)

前言:找了上课时数据结构的教程来看,但是用的语言是c++,所以具体实现在网上搜大神的博客来看,我看到的大神们的博客都写得特别好,不止讲了最基本的思想和算法实现,更多的是侧重于实例运用,一边看一边在心里隐隐歌颂大神的厉害,然后别人的厉害不是我的,所以到底看得各种受打击+头昏脑涨,写这个系列是希望自己能够总结学到东一块.西一下的知识,因为水平有限+经验不足,所以在此只说最基础的思想,附上我自己的算法实现(肯定还有更优解),如果要想看进阶版的,可以在园里搜“数据结构”,各种语言实现和进阶提升的文章有很

数据结构和算法之栈和队列一:两个栈模拟一个队列以及两个队列模拟一个栈

今天我们需要学习的是关于数据结构里面经常看到的两种结构,栈和队列.可以说我们是一直都在使用栈,比如说在前面递归所使用的的系统的栈,以及在链表倒序输出时介绍的自定义栈类Stack和使用系统的栈进行递归.那么,在这里我们就讲述一下这两个比较具有特色的或者说关系比较紧密的数据结构之间的互相实现问题. 一:两个栈模拟实现一个队列: 栈的特点是先进后出,然而队列的特点是先进先出. public class Queen(Stack s1,Stack s2){ //实现插入的方法 public void ad

数据结构与算法—稀疏数组和队列

目录 稀疏数组和队列 1.稀疏数组 1.1 解决方法 1.2 代码实现 2. 队列 2.1 数组模拟队列 2.2 数组模拟环形队列 稀疏数组和队列 1.稀疏数组 所谓稀疏数组就是当数组中大部分的内容值都未被使用(或都为零),在数组中仅有少部分的空间使用.因此造成内存空间的浪费,为了节省内存空间,并且不影响数组中原有的内容值,我们可以使用稀疏数组去压缩数据.OK,如果你不明白,那我们来看一个例子. ? 在一个五子棋中,有存盘和续上盘的功能 分析问题:因为该二维数组的很多默认值是 0,因此记录了很多