栈和队列

最新推荐文章于 2024-07-05 23:46:16 发布
最新推荐文章于 2024-07-05 23:46:16 发布
阅读量737 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leo_wanta/article/details/9314801
版权

1. 栈

  特点: LIFO(Last In First Out)

  应用: 表达式求值, 行编辑, 迷宫求解

// updated 2013-07-15

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef unsigned char u_char_32;
typedef unsigned int  u_int_32;

struct kfifo {
    u_char_32   *buffer;    // the buffer holding the data
    u_int_32    size;       // the size of the allocated buffer
    u_int_32    in;         // the start offset of free section
    u_int_32    out;        // the end offset of data section
};

struct queue {
    struct kfifo fifo;
    int (* queue_init)(struct queue *);
    int (* queue_destroy)(struct queue *);
    int (* queue_clear)(struct queue *);
    int (* queue_empty)(struct queue *);
    u_int_32 (* queue_length)(struct queue *);
    // get data from the head of queue, but 
    // not remove it from the queue.
    int (* queue_peek)(struct queue *, void *, int);
    // put data at the end of queue
    int (* queue_put)(struct queue *, void *, int);
    // get data from the head of queue, and
    // remove it from the queue
    int (* queue_get)(struct queue *, void *, int);

    struct queue *(* queue_dup)(struct queue *);
    // traverse queue step by step
    void (* queue_traverse)(struct queue *, int, void (*)(void *));

    int (* queue_reverse)(struct queue *);
};


#define min(x, y)   ((x) > (y) ? (y) : (x))
#define swap(x, y)  ({  \
    int __tmp = x;  \
    x = y;  \
    y = __tmp;  \
})

#define QUEUE_MAX_SIZE  1024

static void _kfifo_init(struct kfifo *fifo, u_char_32 *buffer, u_int_32 size)
{
    fifo->buffer = buffer;
    fifo->size = size;
    fifo->in = 0;
    fifo->out = 0;
}

static int _kfifo_alloc(struct kfifo *fifo, u_int_32 size)
{
    u_char_32 *buffer = (u_char_32 *)malloc(size);
    if ( !buffer ) {
        _kfifo_init(fifo, NULL, 0);
        return 1;
    }

    _kfifo_init(fifo, buffer, size);
    return 0;
}

static int _M_queue_init(struct queue *q)
{
    if ( !q ) 
        return 1;   // error

    return _kfifo_alloc(&(q->fifo), QUEUE_MAX_SIZE);
}

void _kfifo_free(struct kfifo *fifo)
{
    free(fifo->buffer);
    free(fifo);
}

static int _M_queue_clear(struct queue *q)
{
    if ( !q )
        return 1;   // error

    if ( q->fifo.buffer ) {
        free(q->fifo.buffer);
        q->fifo.in = 0;
        q->fifo.out = 0;
        q->fifo.size = 0;
    }

    return 0;
}

static int _M_queue_destroy(struct queue *q)
{
    if ( !q )
        return 1;   // error

    if ( !q->queue_clear(q) )
        free(q);
    else
        return 1;

    return 0;
}

static int _kfifo_empty(struct kfifo *fifo)
{
    return (fifo->out == fifo->in);
}

static int _M_queue_empty(struct queue *q)
{
    if ( !q )
        return -1;

    return _kfifo_empty(&(q->fifo));
}

static u_int_32 _kfifo_rest(struct kfifo *fifo)
{
    return (fifo->size - fifo->in + fifo->out);
}

static u_int_32 _kfifo_data_size(struct kfifo *fifo)
{
    if ( fifo->in < fifo->out )
        return (fifo->size - fifo->out + fifo->in);
    else
        return (fifo->in - fifo->out);
}

static u_int_32 _M_queue_length(struct queue *q)
{
    if ( !q )
        return -1;   // error

    return _kfifo_data_size(&(q->fifo));
}

static int _kfifo_full(struct kfifo *fifo)
{
    return (_kfifo_rest(fifo) == 0);
}


static int _kfifo_put_data(struct kfifo *fifo, u_char_32 *buffer, u_int_32 len)
{
    if ( _kfifo_rest(fifo) < len )
        return 1;   // fifo is not enough to store data


//
//         out
//          |                    +---------+
//          V                   /           \---> first
//  +-------+------------------+-------------+
//  | free  |       data       |    free     |
//  +-------+------------------+-------------+
//                             ^
//                             |
//                            in 
//
//    u_int_32 section = min(len, (fifo->size - (fifo->in & (fifo->size - 1))));
    u_int_32 first = min(len, fifo->size - fifo->in);
    memcpy(fifo->buffer + fifo->in, buffer, first);
    fifo->in += first;

    if ( len - first > 0 ) {
//
//  in     out
//  |       |                    
//  V       V                   
//  +-------+------------------+-------------+
//  | free  |       data       |   new data  |
//  +-------+------------------+-------------+
//  \       /--> second        
//   +-----+                   
//                             
//
        u_int_32 second = len - first;
        memcpy(fifo->buffer, buffer+first, second);
        fifo->in = second;
    }
    
    return 0;
}

int _M_queue_put(struct queue *q, void *buffer, int size)
{
    if ( !q || !buffer )
        return 1;

    return _kfifo_put_data(&(q->fifo), (u_char_32 *)buffer, (u_int_32)size);
}


int _kfifo_get_data(struct kfifo *fifo, u_char_32 *buffer, u_int_32 len)
{
    if ( _kfifo_data_size(fifo) < len )
        return 1;
    
//
//          in
//          |                    +---------+
//          V                   /           \---> first
//  +-------+------------------+-------------+
//  | data  |       free       |    data     |
//  +-------+------------------+-------------+
//                             ^
//                             |
//                            out
//
//    u_int_32 section = min(len, (fifo->size - (fifo->in & (fifo->size - 1))));
    u_int_32 first = min(len, fifo->size - fifo->out);
    memcpy(buffer, fifo->buffer + fifo->out, first);
    fifo->out += first;

    if ( len - first > 0 ) {
//
// out      in
//  |       |                    
//  V       V                   
//  +-------+------------------+-------------+
//  | data  |       free       |    free     |
//  +-------+------------------+-------------+
//  \       /--> second        
//   +-----+                   
//                            
//
        u_int_32 second = len - first;
        memcpy(buffer+first, fifo->buffer, second);
        fifo->out = second;
    }
    
    return 0;
}

static int _M_queue_get(struct queue *q, void *buffer, int size)
{
    if ( !q )
        return 1;

    // if buffer is NULL, delete the head data
    if ( !buffer ) {
        if ( (u_int_32)size > _kfifo_data_size(&(q->fifo)) )
            return 1;

        u_int_32 len = min((u_int_32)size, q->fifo.size - q->fifo.out);
        if ( (u_int_32)size > len )
            q->fifo.out = (u_int_32)size - len;
        else
            q->fifo.out += len;
    } else {
        _kfifo_get_data(&(q->fifo), (u_char_32 *)buffer, (u_int_32)size);
    }

    return 0;
}

int _kfifo_peek_data(struct kfifo *fifo, u_char_32 *buffer, u_int_32 len)
{
    if ( _kfifo_data_size(fifo) < len )
        return 1;
    
//
//          in
//          |                    +---------+
//          V                   /           \---> first
//  +-------+------------------+-------------+
//  | data  |       free       |    data     |
//  +-------+------------------+-------------+
//                             ^
//                             |
//                            out
//

    u_int_32 first = min(len, fifo->size - fifo->out);
    memcpy(buffer, fifo->buffer + fifo->out, first);

    if ( len - first > 0 ) {
//
//         in
//          |                    
//          V                   
//  +-------+------------------+-------------+
//  | data  |       free       |    data     |
//  +-------+------------------+-------------+
//  \       /--> second        ^
//   +-----+                   |
//                            out
//
        u_int_32 second = len - first;
        memcpy(buffer+first, fifo->buffer, second);
    }
    
    return 0;
}

static int _M_queue_peek(struct queue *q, void *buffer, int size)
{
    if ( !q || !buffer )
        return 1;

    return _kfifo_peek_data(&(q->fifo), (u_char_32 *)buffer, (u_int_32)size);
}

static struct queue *_M_queue_dup(struct queue *q)
{
    struct queue *dup = NULL;
    dup = (struct queue *)malloc(sizeof(struct queue));
    if ( !dup )
        return dup;
    
    queue_register(dup);
    if ( dup->queue_init(dup) ) {
        free(dup);
        return NULL;
    }

    memcpy(dup->fifo.buffer, q->fifo.buffer, dup->fifo.size);
    dup->fifo.in = q->fifo.in;
    dup->fifo.out = q->fifo.out;

    return dup;
}

/*
static int _kfifo_reverse(struct kfifo *fifo)
{
    if ( _kfifo_data_size(fifo) <= 0 )
        return 1;
    u_int_32 len = _kfifo_data_size(fifo);
    u_char_32 *buf = (u_char_32 *)malloc(len);
    if ( !buf )
        return 1;
    if ( fifo->in > fifo->out ) {
        u_int_32 half = len/2;
        u_int_32 rest = len - half;
        memcpy(buf, fifo->buffer + fifo->out, half);
        memcpy(fifo->buffer + fifo->out, 
                    fifo->buffer + fifo->out + rest, half);
        memcpy(fifo->buffer + fifo->out + rest, buf, half);
    } else {
        u_int_32 half = len/2;
        u_int_32 rest = len - half;
        memcpy(buf, fifo->buffer + fifo->out, len);
        u_char_32 tmp[QUEUE_MAX_SIZE];
        memcpy(tmp, buf, half);
        memcpy(buf, buf+rest, half);
        memcpy(buf+rest, tmp, half);

        // copy to fifo->buffer
        half = fifo->size - fifo->out;
        memcpy(fifo->buffer + fifo->out, buf, half);
        memcpy(fifo->buffer, buf + half, len - half);
    }

    free(buf);
    return 0;
}
*/
static int _kfifo_reverse(struct kfifo *fifo)
{
    if ( _kfifo_data_size(fifo) <= 0 )
        return 1;
    u_int_32 len = _kfifo_data_size(fifo)/4;
    u_int_32 i;
    u_int_32 out = fifo->out;
    u_int_32 in = fifo->in;
    
    if ( fifo->size-out > len*4 ) {
        
        //
        //
        //         out  
        //          | 
        //          V
        //  +-------+--------+---------+-------------+
        //  | free  |  1234  |   5678  |    free     |
        //  +-------+--------+---------+-------------+
        //                             ^
        //                             |
        //                            in 
        //
        //         out  
        //          | 
        //          V
        //  +-------+---------+--------+-------------+
        //  | free  |  8765   |  4321  |    free     |
        //  +-------+---------+--------+-------------+
        //                             ^
        //                             |
        //                            in 
        //
        
        for ( i = 0; i < len/2; i++ ) {
            in -= 4;
            swap(*(u_int_32 *)(fifo->buffer + out), *(u_int_32 *)(fifo->buffer + in));
            out += 4;
        }
    } else {
        
        //
        //
        //          in  
        //          |                 
        //          V                
        //  +-------+------------------+----------+--+
        //  |  678  |       free       |  1234    |5 |
        //  +-------+------------------+----------+--+
        //  |       |                 /^            /
        //  |       |                / |           /
        //  |       | +-------------+ out         /
        //  |       |/             +-------------+
        //  |       |             /
        //  +--------+----------+
        //  |  12345 |   678    |
        //  +--------+----------+
        //
        //
        //          in  
        //          |                 
        //          V                
        //  +-------+------------------+-------------+
        //  | 321   |       free       |    87654    |
        //  +-------+------------------+-------------+
        //  |       |                 /^            /
        //  |       |                / |           /
        //  |       | +-------------+ out         /
        //  |       |/             +-------------+
        //  |       |             /
        //  +---------+---------+
        //  |   87654 |  321    |
        //  +---------+---------+
        
        u_int_32 min_len = min(len/2, (fifo->size - out)/4);
        for ( i = 0; i < min_len; i++ ) {
            in -= 4;
            if ( in < 0 )
                in = fifo->size - 4;
            swap(*(u_int_32 *)(fifo->buffer + out), *(u_int_32 *)(fifo->buffer + in));
            out += 4;
        }

        if ( min_len - len/2 > 0 ) {
            out = 0;
            for ( i = 0; i < min_len - len/2; i++ ) {
                in -= 4;
                swap(*(u_int_32 *)(fifo->buffer + out), *(u_int_32 *)(fifo->buffer + in));
                out += 4;
            }
        }
    }

    return 0;
}

static int _M_queue_reverse(struct queue *q)
{
    if ( !q )
        return 1;

    return _kfifo_reverse(&(q->fifo));
}

static void _M_visit(void *buffer)
{
    printf("visit address %p\n", buffer);
}

static void _M_queue_traverse(struct queue *q, int step, void (*visit)(void *))
{
    if ( !q || !visit || !step )
        return ;

    struct queue *dup = q->queue_dup(q);
    if ( !dup )
        return ;

    if ( step > 0 ) {
        // forward
        u_char_32 *buffer = (u_char_32 *)malloc(step);
        while ( !dup->queue_empty(dup) ) {
            dup->queue_get(dup, buffer, (u_int_32)step);
            visit((void *)buffer);
        }
    } else {
        // backward
        u_int_32 size = -step;
        u_char_32 *buffer = (u_char_32 *)malloc(size);
        if ( dup->queue_reverse(dup) ) 
            goto end;
        while ( !dup->queue_empty(dup) ) {
            dup->queue_get(dup, buffer, (u_int_32)size);
            visit((void *)buffer);
        }
    }

end: 
    dup->queue_destroy(dup);
}

int queue_register(struct queue *q)
{
    if ( !q )
        return 1;

    q->queue_init = _M_queue_init;
    q->queue_destroy = _M_queue_destroy;
    q->queue_clear = _M_queue_clear;
    q->queue_empty = _M_queue_empty;
    q->queue_length = _M_queue_length;
    q->queue_peek = _M_queue_peek;
    q->queue_get = _M_queue_get;
    q->queue_put = _M_queue_put;
    q->queue_dup = _M_queue_dup;
    q->queue_traverse = _M_queue_traverse;
    q->queue_reverse = _M_queue_reverse;
}

static void _M_visit_int(void *buffer)
{
    printf("visit %d\n", *(int *)buffer);
}

int testdata[] = {1, 1, 2, 3, 5, 8, 13, 21, 33, 54, 87};

int main()
{
    struct queue squeue;
    queue_register(&squeue);

    squeue.queue_init(&squeue);

    int len = sizeof(testdata)/sizeof(testdata[0]);
    int i;
    for ( i = 0; i < len; i++ ) {
        squeue.queue_put(&squeue, &(testdata[i]), sizeof(testdata[i]));
    }

//    squeue.queue_traverse(&squeue, sizeof(int), _M_visit_int);
    squeue.queue_traverse(&squeue, -4, _M_visit_int);

    int buffer = 0;
    for ( i = 0; i < len; i++ ) {
        squeue.queue_get(&squeue, &buffer, sizeof(buffer));
        printf("%d\n", buffer);
    }

    squeue.queue_clear(&squeue);
    return 0;
}

先贴个写了一半的代码

借鉴了linux kernel kfifo的实现






lancerEx
关注
内核2.6.36版本kfifo代码修改分析
zh1074的专栏
03-23 1712
最近调试openwrt spi驱动，将原来2.6.23版本内核升级到2.6.36，发现调用kfifo相关api函数的代码无法编译通过。原来是内核升级后，kfifo代码进行了修改。以下就列举修改前和修改后的一些差别。 本质上，kfifo修改的目的在于为了使用kfifo api更加通用，而不是像原来内核中kfifo，只能使用在数据元素为字符型（unsigned char）的环形缓冲应用场景。
悟空学Linux专栏----第6篇
悟空学Linux专栏博客
07-08 356
研究了Linux内核的链表之后，悟空第一次被Linux内核高超的设计技巧所吸引，一个简单的双向链表中竟然包含了这么多的道理。悟空深深的被这些看似简单，却十分高效的设计所震撼。所以悟空决定好好的研究一下Linux内核管理数据的数据结构。悟空决定研究的第二数据结构就是队列。 　　然而研究完队列之后悟空感觉有点失望，他无法找到队列的设计中有什么令他感到震惊的地方，更没有什么地方让悟空感到神奇。无非都是
2.6内核kfifo
alpha_007的博客
05-22 272
2.6内核kfifo kfifo.h ```c #include <linux/kernel.h> #include <linux/spinlock.h> #include <linux/stddef.h> #include <linux/scatterlist.h> struct __kfifo { unsigned int in; unsigned int out; unsigned int mask; unsigned int esize;
Linux 内核：匠心独运之无锁环形队列kfifo
热门推荐
遇见你是我最美丽的意外
11-08 1万+
Linux 内核：匠心独运之无锁环形队列 Kernel version Linux 2.6.12 Author Toney Email vip_13031075266@163.com Date 2020.11.8 目录 Linux 内核：匠心独运之无锁环形队列 1. 前言 2. Kfifo简介 3. Kfifo初始化 3.1 判断一个数是否为2的幂次方 3.2 求不小于某个数2的整数次幂 3.3 为什么要求2的幂...
dpdk rte_ring无锁队列 及 内核kfifo
weixin_38679007的博客
06-05 1219
kfifo是内核里面的一个FIFO数据结构，采用环形循环队列的数据结构来实现；它提供一个无边界的字节流服务，最重要的一点是，它使用并行无锁编程技术，即当它用于只有一个入队线程和一个出队线程的场情时，两个线程可以并发操作，而不需要任何加锁行为，就可以保证kfifo的线程安全。 kfifo代码既然肩负着这么多特性，那我们先一敝它的代码：struct kfifo { unsigned char ...
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
linux内核kfifo例子,linux内核入门之kfifo介绍(1)
weixin_39976951的博客
05-02 663
1.介绍kfifo是Linux内核一个通用的队列实现,它提供了两个主要操作:入队(in)和出队(out).kfifo对象维护了两个offset:in offset和out offset.in offset指示了下次入队的位置,而out offset指示了下次出队的位置.入队(in)操作将数据从队列的in offset位置复制到队列中,完成后,in offset的值会加上数据的长度.出队(out)操...
Linux内核中bytestream kfifo学习
sjxpf922的博客
02-22 901
定义kfifo结构体 #define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \ union { \ struct __kfifo kfifo; \ datatype *type; \ const datatype *const_type; \ char (*rectype)[recsize]; \ ptrtype *ptr; \ ptrtype const *ptr_const; \ } #define .
linux内核入门之kfifo介绍(1)
11-03 4544
1.介绍 kfifo是Linux内核一个通用的队列实现,它提供了两个主要操作:入队(in)和出队(out).kfifo对象维护了 两个offset:in offset和out offset.in offset指示了下次入队的位置,而out offset指示了下次出队的 位置. 入队(in)操作将数据从队列的in offset位置复制到队列中,完成后,in offset的值会
linux驱动编程 - kfifo先进先出队列
最新发布
hinewcc的博客
07-05 1105
kfifo先进先出队列
内核无锁队列 -- kfifo
zllbuaa的专栏
02-22 1426
理论证明，在一个生产者和一个消费者的情况下，两者之间的同步无需加锁，即可并发访问。Linux内核无锁队列kfifo完美践行了该理论，性能得到极大提升。工作中如果能使用到该定论，可以有效的提升程序的性能。 内核代码处处有惊喜，往往让人叹为观止，犹如桃花源，让你发现别有洞天的美景。kfifo的实现中使用如下几个trick: 一个整数如果是2的整数幂，那么对齐取余操作%，可以转化为与其&amp;操作，...
内核数据结构之队列
山庄来客的专栏
03-30 3943
<!-- @page {margin:0.79in} p {margin-bottom:0.08in} --> 在操作系统内核中，一个常见的编程模式就是生产者和消费者。实现这种模式的最容易的方式就是队列。生产者将数据插入队列，消费者将数据移出队列。消费者以数据进队的顺序消费数据。 内核中通用队列的实现称为kfifo，其实现文件位于kernel/kfifo.c中。本部分
Linux：内核环形缓存区kfifo使用
Linux
07-12 2017
内核环形缓存区kfifo使用 学习C语言的人有时候会问，去哪里看大佬写的代码，然后自己消化学习。 其实优秀的代码就在你身边：Linux内核。 里面有顶级大师的手笔，有对C语言特性发挥到极致的应用。 没有秀一些冷门的知识，只用大家都熟知的特性，就可以完成牛逼的功能。 最近项目用到了环形缓存区的功能，是典型的消费者和生产者问题。所以想到了内核中的fifo。 想直接把内核中需要的代码拿过来，用到自己的代...
数据结构之内核队列kfifo
u011298001的博客
01-10 3348
kfifo概述 据wiki介绍，环形缓冲区（ring buffer），也称作圆形队列（circular queue），圆形缓冲区（circular buffer），循环缓冲区（cyclic buffer），是一种用于表示一个固定尺寸、头尾相连的缓冲区的数据结构，适合缓存数据流。 圆形缓冲区的一个有用特性是：当一个数据元素被用掉后，其余数据元素不需要移动其存储位置。相反，一个非圆形缓冲区（例如一...
内核中的kfifo的例子
Android开发
03-25 4504
关于内核的kfifo介绍，可参考http://www.cnblogs.com/Anker/p/3481373.html 咱玩一点理论性没这么强的东西，先那个例子来跑一下就知道是怎么回事了。这里以内核下的samples/kfifo/record-example.c为例 /* * Sample dynamic sized record fifo implementation * *
栈和队列操作实现
"该资源是关于栈和队列的数据结构练习，包含C语言实现的代码，涉及栈的入栈、出栈以及队列的入队、出队等基本操作。" 在计算机科学中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据时遵循特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值