小肥柴慢慢手写数据结构（C篇）（4-1 队列Queue）

已于 2023-11-23 16:17:45 修改
阅读量521 收藏 1
点赞数 1
文章标签： 数据结构 c语言 链表
于 2021-10-25 22:39:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39635634/article/details/120952782
版权

小肥柴慢慢学习数据结构笔记（C篇）（4-1 队列Queue）

目录

4-1 队列概念

如下图，（一般）队列相当于一个管道，元素类似于管道里的小球；规定仅允许从管道的末尾放入小球，仅允许从管道的头部取出小球；这样就自然形成了一个“先进先出的结构”（FIFO），让所有小球在管道中排队。
在这里插入图片描述
由于需要存储“一组”数据，队列所以既可以选择使用链表实现，也可以选择使用数组实现；其中链表实现相对简单，因为只需要一个单向链表，保留删除头结点（出队列）和尾插（入队列）两个操作就能复用之前的很多代码了；若使用数组实现则有一个容积问题和回转问题，下面我们分别实现这两套方案的代码。

4-2 基于链表的实现

关键操作：
（1）Enqueue( ) 入队列 ：链表尾插
（2）Dequeue( ) 出队列 ：删除头结点
上代码：
（1）QueueLink.h
这里我们简单实现了链表中尾插和删头两个操作，也可以复用之前实现的单链表；所有函数名字清晰，不做解释。

typedef int ElementType;
#ifndef _Queue_Link_h
#define _Queue_Link_h
typedef struct Node{
	ElementType data;
	struct Node *next;
}Node;

struct QueueLink{
	Node *Front;
	Node *Rear;
};

typedef struct QueueLink *Queue; 

int IsEmpty( Queue Q );
Queue CreateQueue( );
void DisposeQueue( Queue Q );
void Enqueue( ElementType X, Queue Q );
ElementType Front( Queue Q );
void Dequeue( Queue Q );
ElementType FrontAndDequeue( Queue Q );
#endif

（2）QueueLink.c

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

#include "QueueLink.h"

int IsEmpty( Queue Q ){
	return Q->Front == NULL;
}

Queue CreateQueue( ){
    Queue Q = malloc(sizeof(struct QueueLink));
    if( Q == NULL )
    	printf( "CreateQueue: Out of space!!!\n" );
	else
		Q->Front = Q->Rear = NULL;
	return Q;
}

void Enqueue( ElementType X, Queue Q ){
	Node *node = (Node *)malloc(sizeof(Node));
	if(node == NULL)
		printf( "Enqueue: Out of space!!!\n" );
	else{
		node->data = X;
		node->next = NULL;
		if(Q->Rear==NULL){
			Q->Front = node;
			Q->Rear = node;
		} else {
			Q->Rear->next = node;
			Q->Rear = node;
		}
	}
}

void Dequeue( Queue Q ){
    if( IsEmpty( Q ) )
        printf( "Empty queue\n" );
    else {
    	Node * node = Q->Front;
		if(Q->Front == Q->Rear)
			Q->Front = Q->Rear = NULL;
		else
			Q->Front = Q->Front->next;
		free(node);
    }
}

ElementType Front( Queue Q ){
    if( !IsEmpty( Q ) )
        return Q->Front->data;
    printf( "Empty queue\n" );
    return 0;
}

ElementType FrontAndDequeue( Queue Q ){
	int data = 0;
    if( IsEmpty( Q ) )
        printf( "Empty queue\n" );
    else {
    	Node *node = Q->Front;
    	data = node->data;
		if(Q->Front == Q->Rear)
			Q->Front = Q->Rear = NULL;
		else
			Q->Front = Q->Front->next;
		free(node);
    }
    return data;
}

void DisposeQueue( Queue Q ){
	if(Q != NULL){
		Node *cur = Q->Front;
		while(cur->next != NULL){
			Node *node = cur;
			free(node);
			cur = cur->next;
		}
		Q->Front = NULL;
		Q->Rear = NULL;
		free(Q);
		Q = NULL;
	}
}

void showQueue(Queue Q){
	Node *cur = Q->Front;
	while(cur->next != NULL){
		printf(" %d", cur->data);
		cur = cur->next;
	}
	printf(" %d\n", cur->data);
}

这里的dequeue( )也可以改为返回被删除的头结点元素，按需实现。
（3）测试文件Main.c

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

#include "QueueLink.h"

int main(int argc, char *argv[]) {
	int i, size = 5;
	Queue Q = CreateQueue();
	printf( "Enqueue start:\n" );
	for(i=0; i<size; i++)
		Enqueue(i+1, Q);
	
	printf("\nShow Queue: ");
	showQueue(Q);
	
	printf("\nFront Element:%d", Front(Q));
	printf("\nShow Queue: ");
	showQueue(Q);
	
	printf("\nFrontAndDequeue Element:%d", FrontAndDequeue(Q));
	printf("\nShow Queue: ");
	showQueue(Q);
	
	printf("\nDequeue:");
	Dequeue(Q);
	printf("\nShow Queue: ");
	showQueue(Q);
	
	DisposeQueue(Q);
	
	return 0;
}

【测试结果】
在这里插入图片描述

4-3 基于数组的实现（循环队列）

对于基于数组的队列来讲，有以下几个问题需要明确：（对比ArrayList，其实也可以用ArrayList为蓝本来实现队列）
（1）标记数组中最后一个有效元素的索引为rear，此时如果添加新元素，那么rear++，且将新元素放入已经更新的arr[rear]中；
（2）标记数组中第一个有效元素的索引为front，此时如果删除元素，则front++，也就是“避开”了旧头元素；
在这里插入图片描述
（3）假设设定数组的容量是capacity，如果在元素填充满后继续添加元素，那么必然rear出现“回绕”，也就是重新从index=0开始，后续继续添加就是覆盖了。
（4）同理如果rear<front，说明已经回绕了，假设front==size-1，此时出队列front也需要回绕。

我认为初学者并不需要画出环形图来表达以上过程，一个简单的线形图足矣帮助理解问题，特别是对两个基准front和rear的移动，综上分析：
（1）对front和rear两个标记，解决回绕是一个共性问题；
（2）循环队列的核心就是front和rear；
（3）检测队列为空是非常重要的；
（4）每个人对front和rear的实现细节上可能存在差异。
接下来上代码：
（1）QueueArray.h

typedef int ElementType;
#ifndef _Queue_Array_h
#define _Queue_Array_h

struct QueueRecord{
    int Capacity;
    int Front;
    int Rear;
    int Size;
    ElementType *Array;
};
typedef struct QueueRecord *Queue;

int IsEmpty( Queue Q );
int IsFull( Queue Q );
Queue CreateQueue( int MaxElements );
void DisposeQueue( Queue Q );
void MakeEmpty( Queue Q );
void Enqueue( ElementType X, Queue Q );
ElementType Front( Queue Q );
void Dequeue( Queue Q );
ElementType FrontAndDequeue( Queue Q );

#endif  /* _Queue_h */

（2）QueueArray.c

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

#include "QueueArray.h"

#define MinQueueSize ( 5 )

int IsEmpty( Queue Q ){
	return Q->Size == 0;
}

int IsFull( Queue Q ){
    return Q->Size == Q->Capacity;
}

Queue CreateQueue( int MaxElements ){
    Queue Q = NULL;
    if( MaxElements < MinQueueSize ){
    	printf("Queue size is too small\n");
    	return NULL;
	}

    Q = malloc( sizeof( struct QueueRecord ) );
    if( Q == NULL ){
    	printf( "Out of space!!!\n" );
    	return NULL;
	}

    Q->Array = malloc( sizeof( ElementType ) * MaxElements );
    if( Q->Array == NULL ){
	    printf( "Out of space!!!\n" );
	    free(Q);
	    return NULL;
	}

    Q->Capacity = MaxElements;
    MakeEmpty( Q );

    return Q;
}

void MakeEmpty( Queue Q ){
    Q->Size = 0;
    Q->Front = 1;
    Q->Rear = 0;
}

void DisposeQueue( Queue Q ){
    if( Q != NULL ){
        free( Q->Array );
        free( Q );
    }
}


static int Succ( int Value, Queue Q ){
    if( ++Value == Q->Capacity )
        Value = 0;
    return Value;
}

void Enqueue( ElementType X, Queue Q ){
    if( IsFull( Q ) ){
    	printf( "Full queue\n" );
	} else {
        Q->Size++;
        Q->Rear = Succ( Q->Rear, Q );
        Q->Array[ Q->Rear ] = X;
    }
}

ElementType Front( Queue Q ){
    if( !IsEmpty( Q ) )
        return Q->Array[ Q->Front ];
    printf( "Empty queue\n" );
    return 0;
}

void Dequeue( Queue Q ){
    if( IsEmpty( Q ) )
        printf( "Empty queue\n" );
    else {
        Q->Size--;
        Q->Front = Succ( Q->Front, Q );
    }
}

ElementType FrontAndDequeue( Queue Q ){
    ElementType X = 0;

    if( IsEmpty( Q ) )
        printf( "Empty queue\n" );
    else {
        Q->Size--;
        X = Q->Array[ Q->Front ];
        Q->Front = Succ( Q->Front, Q );
    }
    return X;
}

void showQueue(Queue Q){
	int cur = Q->Front;
	while(cur != Q->Rear){
		printf(" %d", Q->Array[cur]);
		cur = Succ(cur, Q);
	}
	printf(" %d\n", Q->Array[cur]);
}

有几个细节需要思考：
<1> 对于回绕，我们抽象出一个共性工具函数Succ()

static int Succ( int Value, Queue Q ){
    if( ++Value == Q->Capacity )
        Value = 0;
    return Value;
}

这里入参value其实就是index，如果++之后到达capacity，就应该回绕了（value=0）；否则什么都不做。
<2> 初始化函数CreateQueue( )中，使用MakeEmpty( )来初始化front和rear

void MakeEmpty( Queue Q ){
    Q->Size = 0;
    Q->Front = 1;
    Q->Rear = 0;
}

用size来判断empty和full

int IsEmpty( Queue Q ){
	return Q->Size == 0;
}

int IsFull( Queue Q ){
    return Q->Size == Q->Capacity;
}

而front和rear不参与以上两个函数，这里是一个小trick：原书作者希望使用rear=front-1来判空，以满足某些程序设计人员依靠基准来隐式推算类似队列大小等数据，但实际上我们的模仿黑皮书的代码并不是完美的，市面上还有很多别的形式的实现，特别对于回绕，使用%计算：
1> 首先front=rear=0初始化；
2> 接着使用取模运算实现回转

Q->rear = (Q->rear+1)%MAXSIZE; //入队
Q->front = (Q->front+1)%MAXSIZE; //出队

3）还能使用两个基准计算元素个数，从而不用维护size属性（有优势也有劣势，优势就是节省了一点点空间，劣势就是每次获取size都要重新计算一遍）

//返回长度
int getLenth(LoopQueue *Q) {
	return (Q->rear - Q->front + MAXSIZE)%MAXSIZE;
}

有兴趣的同学，可以参考文献[1]重新改写下，万事皆有两面性，建议再看看参考文献[2]，也重写一遍；还是那句话：根据具体需要适度改进数据结构。且后续使用数据结构的时候，除非性能压榨，否则是不会改动已经设计好的数据结构的；当然我对黑皮书中这段代码的描述也并不是很满意，如果说不使用%运算是因为其相对效率不高（真的只是相对的，并没有那么不堪），那这种设计还是可以接受的。
（3）Main.c

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

#include "QueueArray.h"

int main(int argc, char *argv[]) {
	int i, size = 5;
	Queue Q = CreateQueue(size);
	printf( "Enqueue start:\n" );
	for(i=0; i<size; i++)
		Enqueue(i+1, Q);
		
	printf("\nShow Queue: ");
	showQueue(Q);
	
	printf("Front Element:%d\n", Front(Q));
	printf("\nShow Queue: ");
	showQueue(Q);
	
	printf("FrontAndDequeue Element:%d\n", FrontAndDequeue(Q));
	printf("\nShow Queue: ");
	showQueue(Q);
	
	printf("Dequeue:\n");
	Dequeue(Q);
	printf("\nShow Queue: ");
	showQueue(Q);
	
	return 0;
}

【测试结果】
在这里插入图片描述

4-4 严版教材的实现

1.单链队列
（1）c3-2.h

 // c3-2.h 单链队列－－队列的链式存储结构
 typedef struct QNode
 {
   QElemType data;
   QNode *next;
 }*QueuePtr;

 struct LinkQueue
 {
   QueuePtr front,rear; // 队头、队尾指针
 };

（2）bo3-2.cpp，相关实现也非常简单

 // bo3-2.cpp 链队列(存储结构由c3-2.h定义)的基本操作(9个)
 Status InitQueue(LinkQueue &Q)
 { // 构造一个空队列Q
   if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
     exit(OVERFLOW);
   Q.front->next=NULL;
   return OK;
 }

 Status DestroyQueue(LinkQueue &Q)
 { // 销毁队列Q(无论空否均可)
   while(Q.front)
   {
     Q.rear=Q.front->next;
     free(Q.front);
     Q.front=Q.rear;
   }
   return OK;
 }

 Status ClearQueue(LinkQueue &Q)
 { // 将Q清为空队列
   QueuePtr p,q;
   Q.rear=Q.front;
   p=Q.front->next;
   Q.front->next=NULL;
   while(p)
   {
     q=p;
     p=p->next;
     free(q);
   }
   return OK;
 }

 Status QueueEmpty(LinkQueue Q)
 { // 若Q为空队列,则返回TRUE,否则返回FALSE
   if(Q.front==Q.rear)
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(LinkQueue Q)
 { // 求队列的长度
   int i=0;
   QueuePtr p;
   p=Q.front;
   while(Q.rear!=p)
   {
     i++;
     p=p->next;
   }
   return i;
 }

 Status GetHead(LinkQueue Q,QElemType &e)
 { // 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR
   QueuePtr p;
   if(Q.front==Q.rear)
     return ERROR;
   p=Q.front->next;
   e=p->data;
   return OK;
 }

 Status EnQueue(LinkQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素
   QueuePtr p;
   if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
     exit(OVERFLOW);
   p->data=e;
   p->next=NULL;
   Q.rear->next=p;
   Q.rear=p;
   return OK;
 }

 Status DeQueue(LinkQueue &Q,QElemType &e)
 { // 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR
   QueuePtr p;
   if(Q.front==Q.rear)
     return ERROR;
   p=Q.front->next;
   e=p->data;
   Q.front->next=p->next;
   if(Q.rear==p)
     Q.rear=Q.front;
   free(p);
   return OK;
 }

 Status QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi()。一旦vi失败,则操作失败
   QueuePtr p;
   p=Q.front->next;
   while(p)
   {
     vi(p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
 }

2.循环队列
（1）c3-3.h 队列的顺序存储结构(可用于循环队列和非循环队列)

 #define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减1)
 struct SqQueue
 {
   QElemType *base; // 初始化的动态分配存储空间
   int front; // 头指针,若队列不空,指向队列头元素
   int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
 };

（2）bo3-3.cpp 循环队列，这里多了一个base基址，给后续拓展操作流出尾巴

 // bo3-3.cpp 循环队列(存储结构由c3-3.h定义)的基本操作(9个)
 Status InitQueue(SqQueue &Q)
 { // 构造一个空队列Q
   Q.base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
   if(!Q.base) // 存储分配失败
     exit(OVERFLOW);
   Q.front=Q.rear=0;
   return OK;
 }

 Status DestroyQueue(SqQueue &Q)
 { // 销毁队列Q,Q不再存在
   if(Q.base)
     free(Q.base);
   Q.base=NULL;
   Q.front=Q.rear=0;
   return OK;
 }

 Status ClearQueue(SqQueue &Q)
 { // 将Q清为空队列
   Q.front=Q.rear=0;
   return OK;
 }

 Status QueueEmpty(SqQueue Q)
 { // 若队列Q为空队列,则返回TRUE,否则返回FALSE
   if(Q.front==Q.rear) // 队列空的标志
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(SqQueue Q)
 { // 返回Q的元素个数,即队列的长度
   return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
 }

 Status GetHead(SqQueue Q,QElemType &e)
 { // 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=*(Q.base+Q.front);
   return OK;
 }

 Status EnQueue(SqQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素
   if((Q.rear+1)%MAXQSIZE==Q.front) // 队列满
     return ERROR;
   Q.base[Q.rear]=e;
   Q.rear=(Q.rear+1)%MAXQSIZE;
   return OK;
 }

 Status DeQueue(SqQueue &Q,QElemType &e)
 { // 若队列不空,则删除Q的队头元素,用e返回其值,并返回OK;否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAXQSIZE;
   return OK;
 }

 Status QueueTraverse(SqQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi().一旦vi失败,则操作失败
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(*(Q.base+i));
     i=(i+1)%MAXQSIZE;
   }
   printf("\n");
   return OK;
 }

（3）顺序队列：这个扩容操作一言难尽

 // bo3-4.cpp 顺序队列(非循环,存储结构由c3-3.h定义)的基本操作(9个)
 Status InitQueue(SqQueue &Q)
 { // 构造一个空队列Q
   Q.base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
   if(!Q.base) // 存储分配失败
     exit(OVERFLOW);
   Q.front=Q.rear=0;
   return OK;
 }

 Status DestroyQueue(SqQueue &Q)
 { // 销毁队列Q,Q不再存在
   if(Q.base)
     free(Q.base);
   Q.base=NULL;
   Q.front=Q.rear=0;
   return OK;
 }

 Status ClearQueue(SqQueue &Q)
 { // 将Q清为空队列
   Q.front=Q.rear=0;
   return OK;
 }

 Status QueueEmpty(SqQueue Q)
 { // 若队列Q为空队列,则返回TRUE,否则返回FALSE
   if(Q.front==Q.rear) // 队列空的标志
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(SqQueue Q)
 { // 返回Q的元素个数,即队列的长度
   return(Q.rear-Q.front);
 }

 Status GetHead(SqQueue Q,QElemType &e)
 { // 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=*(Q.base+Q.front);
   return OK;
 }

 Status EnQueue(SqQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素
   if(Q.rear>=MAXQSIZE)
   { // 队列满，增加1个存储单元
     Q.base=(QElemType *)realloc(Q.base,(Q.rear+1)*sizeof(QElemType));
     if(!Q.base) // 增加单元失败
       return ERROR;
   }
   *(Q.base+Q.rear)=e;
   Q.rear++;
   return OK;
 }

 Status DeQueue(SqQueue &Q,QElemType &e)
 { // 若队列不空,则删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=Q.base[Q.front];
   Q.front=Q.front+1;
   return OK;
 }

 Status QueueTraverse(SqQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi()。一旦vi失败,则操作失败
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(*(Q.base+i));
     i++;
   }
   printf("\n");
   return OK;
 }

（4）还有链栈结构，但我觉得这个结构并不是那么的实用，就不贴出来了，其实上面的非循环队列的实现，是没有必要封装的那么复杂的，完全可以用最简单数组和两个基准去实现其核心功能，简单的才是最好的，这也是我看过Linux内核代码以及对《啊哈，算法》这本书作者思想的理解，数据结构本身就是为了更好的实现程序算法而服务的，千万不能陷入为了数据结构和设计数据结构的小路。

4-5 Linux代码中Queue案例

这里的典型例子就是kfifo，网上大多数帖子都已2.6版本为例做代码讲解。具体信息如下（截图，侵删）：
在这里插入图片描述
相关代码如下：

//根据给定buffer创建一个kfifo
  struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
                  gfp_t gfp_mask, spinlock_t *lock);
  //给定size分配buffer和kfifo
  struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask,
                   spinlock_t *lock);
  //释放kfifo空间
  void kfifo_free(struct kfifo *fifo);
  //向kfifo中添加数据
  unsigned int kfifo_put(struct kfifo *fifo,
                 const unsigned char *buffer, unsigned int len);

  //从kfifo中取数据
  unsigned int kfifo_get(struct kfifo *fifo,
                 unsigned char *buffer, unsigned int len);
　//获取kfifo中有数据的buffer大小 
　unsigned int kfifo_len(struct kfifo *fifo);

实际到了3.9中：

/**
 * kfifo_init - initialize a fifo using a preallocated buffer
 * @fifo: the fifo to assign the buffer
 * @buffer: the preallocated buffer to be used
 * @size: the size of the internal buffer, this have to be a power of 2
 *
 * This macro initialize a fifo using a preallocated buffer.
 *
 * The numer of elements will be rounded-up to a power of 2.
 * Return 0 if no error, otherwise an error code.
 */
#define kfifo_init(fifo, buffer, size) \
({ \
	typeof((fifo) + 1) __tmp = (fifo); \
	struct __kfifo *__kfifo = &__tmp->kfifo; \
	__is_kfifo_ptr(__tmp) ? \
	__kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \
	-EINVAL; \
})

进一步看细节

int __kfifo_init(struct __kfifo *fifo, void *buffer,
		unsigned int size, size_t esize)
{
	size /= esize;

	size = roundup_pow_of_two(size);

	fifo->in = 0;
	fifo->out = 0;
	fifo->esize = esize;
	fifo->data = buffer;

	if (size < 2) {
		fifo->mask = 0;
		return -EINVAL;
	}
	fifo->mask = size - 1;

	return 0;
}

这里的in和out不就是对应rear和front吗？

unsigned int __kfifo_in(struct __kfifo *fifo,
		const void *buf, unsigned int len)
{
	unsigned int l;

	l = kfifo_unused(fifo);
	if (len > l)
		len = l;

	kfifo_copy_in(fifo, buf, len, fifo->in);
	fifo->in += len;
	return len;
}

其实还有一个常见的例子：Workqueue，基于链表的queue，有兴趣的同学可以自己查看下参考文献[7]/[8]。

小结：使用queue的目的就是让元素（事件/作业/任务）排队等待处理，因为它仅有一个出口和一个入口。

[1] 数据结构(C语言)-循环队列基本操作
[2] 数据结构（C语言）-链队列基本操作
[3] Linux内核中常用的数据结构和算法
[4] 0Linux 内核：匠心独运之无锁环形队列
[5] Linux内核数据结构之kfifo详解
[6] linux内核之Kfifo环形队列
[7] Linux-workqueue讲解(Linux3.9内核)
[8] Linux内核中的Workqueue机制分析

卷毛迷你猪
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
使用C++手写队列 - Queue
PGZXB的博客
01-21 1334
使用C++手写队列 我们使用C++写过了Vector、Stack，这篇文章我们来写一下队列Queue； Queue的特点是先进先出，或者说满足这一特性的我们可以称之为队列； 和栈Stack一样，Queue只是定义了一组操作，满足一系列操作的就可以称为队列，此次我们采用顺序表进行实现，即对C++的动态数组进行简单的封装并且提供一系列队列应有的操作； 在我们实现Stack的时候，我们利用了我们写的Vector，那么为什么这次不继续使用而是从最基本的动态数组入手呢。这是因为Queue的特性是先进先出，即队尾进，
【数据结构】手写循环顺序队列【纯c语言版】
weixin_43113381的博客
11-16 326
摘要：本章主要讲述循环顺序队列的实现 文章目录1.队列的定义和特点2.队列的顺序结构2.1 普通队列2.2 循环队列3. 循环队列的代码实现3.1 队列的初始化3.1 队列增容3.2 队列的判空操作3.3 队列的判满操作3.4 入队操作3.5 出队操作3.6 清空队列3.7 销毁队列4. 源码链接(含测试代码)文章索引后记 1.队列的定义和特点 定义 队列(Queue)是只允许在一端进行插入操作，而在另-端进行删除操作的线性表 队列是一种先进先出(First In First Out)的线性表 允许插
[数据结构与算法] : 队列
weixin_30357231的博客
09-10 58
头文件 1 typedef int ElementType; 2 3 #ifndef _QUEUE_H_ 4 #define _QUEUE_H_ 5 6 struct QueueRecord; 7 typedef struct QueueRecord *Queue; 8 9 int IsEmpty(Queue Q); 10 int IsFull(Qu...
顺序存储队列 -- 不循环队列和循环队列
xuechanba的博客
09-15 663
队列的特点：先进先出 视频链接地址：https://www.bilibili.com/video/BV18p4y167Md?p=99. 顺序存储的不循环队列 我们使用两个标记来记录数组下标的位置，以方便入队和出队。 这两个标记呢，可以使用指针变量，也可以使用数组的下标（int类型的变量），我们通常称之为队头指针（head 或 front）和队尾指针(rear 或tail)。 （下图中的队头指针和队尾指针都是指向下标为0的数组区域。） 我们可以使用队头指针来入队也可以使用队尾指针来入队，但是当队头指针来入队
linux编译c文件for循环,Linux C 循环队列的实现
weixin_30601893的博客
05-05 305
1、创建circle_queue.h 文件#ifndef CIRCLE_QUEUE_H_#define CIRCLE_QUEUE_H_#define SUCCESS 1#define FAILED -1typedef int QElemType;// 队列的顺序存储结构(可用于循环队列和非循环队列)#define MAXSIZE 1000 // 最大队列长度(对于循环队列，最大队列长度要减1)ty...
golang 手写c/s 消息队列列表
06-03
本篇文章将深入探讨如何使用Golang手写一个C/S消息队列系统，并结合Redis数据库实现消息的互发、登录、退出同步等功能。 首先，我们要理解消息队列（Message Queue）的作用。消息队列是一种中间件，用于解耦生产者...
Python-一个由python写简单和容易使用的消息队列
08-11
1. **设计数据结构**：首先，你需要确定如何存储消息。这可能是数据库中的记录，文件系统中的文件，或者是内存中的数据结构。考虑到“简单”和“易用”的特点，一个可能的实现是使用Python的内置`queue`模块，它提供...
算法之二叉树的层序遍历（利用队列实现，需熟练手写）
01-20
在这个过程中，队列作为一种先进先出（FIFO，First In First Out）的数据结构，被广泛应用于实现层序遍历。在Java中，我们可以使用`java.util.Queue`接口以及它的具体实现，如`ArrayDeque`或`LinkedList`来完成这一...
algorithms:经典数据结构、算法、面试题的Java实现
06-25
- **数据结构实现**：要求手写数据结构的实现，如栈、队列、哈希表等。 - **性能优化**：内存管理、算法效率、代码重构等，考察实际开发中的优化技巧。 通过这个项目，你可以学习到如何用Java实现上述的各种数据...
Java实现简单的阻塞队列2种方式
06-10
在Java编程中，阻塞队列是一种特殊类型的并发数据结构，它在多线程环境中的应用广泛，主要用于线程间的协作通信。阻塞队列在队列满时会阻止生产者线程添加元素，在队列空时会阻止消费者线程取出元素，直到条件满足...
常用数据结构 ——— 队列（环形队列和顺序队列）
学习记录，交流学习
12-02 2552
主要介绍了顺序队列和环形队列的特点，以及用C语言实现了环形队列
队列（Queue）C语言实现 详解
qq_52208569的博客
02-18 5766
文章目录前言一、队列的概念及结构二、实现队列1.实现队列建议用什么结构？2.接口的设计3.接口的实现三、测试数据总结 前言 你们在用电脑时有没有经历，机器有时会处于疑似死机的状态，鼠标点什么似乎都没用，双击任何快捷方式都不动弹。就当你失去耐心，打算rest时。突然他像酒醒了一样，把你刚才点击的所有操作全部按顺序执行一遍。这其实是因为操作系统中的多个程序因需要通过一个通道输出，而按先后次序排队等待造成的。这里应用了一种数据结构来实现刚才提到的先进先出的排队功能，这就是队列。本文就对算法中的队列进行简单的总结
内核循环缓冲区数据结构kfifo在用户态的使用
mergerly的专栏
09-02 4110
忘记了之前是有个什么事情一时想起好像需要用个cycler buffer，手头一时又没有，懒得自己实现。就向同学要了个。后来好像也没有用到，倒是一直记得好像老早以前看到ldd上提到双向链表的时候有提到个kfifo，只是一直没有用到这个，所以一直没看。倒是无聊的时候想起过printk是否用的就是这个数据结构。 　　昨天临下班的时候想到kfifo这个东东，今天就抽点时间看看。 　　刚开始是把
linux内核数据结构实现--链表、队列和哈希
网络安全研究
01-09 838
C是面向过程的语言，但是linux内核却用C实现了一套面向对象的设计模式，linux内核中处处体现着面向对象的思想。
数据结构与算法分析-队列
u011714517的博客
01-20 307
队列ADT 像栈一样，队列（queue）也是表。然而，使用队列时插入在一端进行而删除则在另一端进行。 队列模型 队列的基本操作是EnqueueEnqueueEnqueue（入队），它是在表的末端（叫做队尾（rear））插入一个元素，还有DequeueDequeueDequeue（出队），它是删除（或返回）在表的开头（叫做队头（front））的元素。 队列的数组实现 如同栈的情形一样，对于队列而言任...
数据结构学习之——（c/c++实现）手写单链表（删除、插入、查找、建表）
dustnn的博客
02-15 730
在家整理了一下数据结构方面的知识，想自己动手实现一个单链表。主要实现操作有： 通过尾插法建立单链表 通过匹配的值开查找链表中的元素 通过序列来去链表中的元素 插入元素（前插、后插） 删除元素 遍历显示 下面就是代码了：首先是主函数 main.cpp #include <iostream> #include"lklist.h" using namespace std; int ma...
数据结构-Dequeue
qq_29286967的博客
07-11 9866
Deque        deque（也称为双端队列）是与队列类似的项的有序集合。它有两个端部，首部和尾部，并且项在集合中保持不变。deque 不同的地方是添加和删除项是非限制性的。可以在前面或后面添加新项。同样，可以从任一端移除现有项。如下展示了一个 Python 数据对象的 deque 。    deque 抽象数据类型由以下结构和操作定义。如上所述，deque 被构造为项的有序集合，其中项从...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 98
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 184
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
"清华殷人昆数据结构笔记（C语言）4: 栈、队列、优先队列
//---------------------------------小结栈、队列和优先队列是常用的数据结构，它们都是线性表的扩展形式，具有各自特定的特点和应用场景。栈适合处理嵌套结构的问题，队列适合模拟排队等待的情况，而优先队列适合...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值