数据结构 队列

已于 2024-03-22 17:58:25 修改
阅读量208 收藏
点赞数 2
文章标签： 数据结构
于 2024-03-22 17:50:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65339175/article/details/136948068
版权

队列：

特点：

1、队列是只允许在一段插入，而在另一端进行删除操作的线性表

2、允许插入的称为队尾，允许删除的一端对头

3、先进先出，FIFO。

物理机构：

    顺序队列

    循环队列

常规操作 ：入队 出队

顺序表队列：

seqqueue.h:



#ifndef _SEQQUE_H_
#define _SEQQUE_H_

typedef int DATATYPE;
typedef struct  {
	DATATYPE *array;
	int tlen;
	int head;
	int tail;
}SeqQueue;

SeqQueue *CreateSeqQueue(int len);
int DestroySeqQueue(SeqQueue *queue);
int QuitSeqQueue(SeqQueue *queue);
int EnterSeqQueue(SeqQueue *queue, DATATYPE *data);
int IsEmptySeqQueue(SeqQueue *queue);
int IsFullSeqQueue(SeqQueue *queue);
DATATYPE* GetHeadSeqQueue(SeqQueue* queue);
#endif

seqqueue.c

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

SeqQueue *CreateSeqQueue(int len)
{
    SeqQueue* sq =(SeqQueue*)malloc(sizeof(SeqQueue));    
    if(NULL == sq)
    {
        perror("CreateSeqQueue malloc");
        return NULL;
    }

    sq->array = (DATATYPE*)malloc(sizeof(DATATYPE)*len);
    if(NULL == sq->array)
    {
        perror("CreateSeqQueue");
        return NULL;
    }
    sq->tlen = len;
    sq->head  = 0 ;
    sq->tail = 0 ;
    return sq;
}
int DestroySeqQueue(SeqQueue *queue)
{

    return 0;
}
int QuitSeqQueue(SeqQueue *queue)
{

    if(IsEmptySeqQueue(queue))
    {
        return 1;
    }
    queue->head = (queue->head +1)%queue->tlen ;
    return 0;
}
int EnterSeqQueue(SeqQueue *queue, DATATYPE *data)
{
    if(IsFullSeqQueue(queue))
    {
        return 1;
    }
    memcpy(&queue->array[queue->tail],data,sizeof(DATATYPE));
    queue->tail = (queue->tail +1)%queue->tlen;
    return 0;
}
int IsEmptySeqQueue(SeqQueue *queue)
{

    return  queue->head == queue->tail ;
}
int IsFullSeqQueue(SeqQueue *queue)
{
    return (queue->tail +1 )%queue->tlen  == queue->head ;
}
DATATYPE* GetHeadSeqQueue(SeqQueue* queue)
{
    if(IsEmptySeqQueue(queue)) return  NULL;
    return &queue->array [queue->head];
}

 示例：



#include "seqque.h"
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include <unistd.h>
sem_t sem_task;

void* th1(void* arg)
{
    SeqQueue* sq =(SeqQueue*) arg;
    DATATYPE data;
    while(1)
    {
        bzero(&data,sizeof(data));
        sem_wait(&sem_task);
        DATATYPE* tmp = GetHeadSeqQueue(sq);
        memcpy(&data,tmp,sizeof(DATATYPE));
        QuitSeqQueue(sq);
        if(0 == strcmp(data.task_name ,"over"))
        {
            break;
        }
        while(data.task_time--)
        {
            printf("I'm %s\n",data.task_name);
            sleep(1);
        }
    }
    return NULL;
}
int main(int argc, char *argv[])
{

    DATATYPE data []=
    {
        {"cooking", 5},
        {"washing", 3},
        {"working", 8},
        {"playing", 5},
        {"over",0},

    };
    SeqQueue* sq = CreateSeqQueue(10);

    pthread_t tid1;
    sem_init(&sem_task,0,0);
    pthread_create(&tid1,NULL,th1,sq);
    DATATYPE dat;
    while(1)
    {
        bzero(&dat,sizeof(dat));
        char buf[5]={0};// 1 2 3 4 5\n
        int num = 0 ;
        fgets(buf,sizeof(buf),stdin);
        num = atoi(buf);
        //dat  = data[num-1];
        memcpy(&dat,&data[num-1],sizeof(DATATYPE));
        EnterSeqQueue(sq,&dat);
        sem_post(&sem_task);
        
        if(0 ==strcmp(dat.task_name ,"over"))
        {
            break;
        }

    }
    pthread_join(tid1,NULL);
    sem_destroy(&sem_task);
    DestroySeqQueue(sq);
    return 0;
}

链式表队列：

linkqueue.h:

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

typedef int DATATYPE;
typedef struct link_que_node {
	DATATYPE data;
	struct link_que_node *next;
}QueueNode;

typedef struct  {
	QueueNode *head;
	int clen;
	QueueNode *tail;
}LinkQueue;
LinkQueue *CreateLinkQueue();
int DestroyLinkQueue(LinkQueue *queue);
int QuitLinkQueue(LinkQueue *queue);
DATATYPE* GetHeadLinkQue(LinkQueue*queue);
int EnterLinkQueue(LinkQueue *queue, DATATYPE *data);
int IsEmptyLinkQueue(LinkQueue *queue);
#endif

linkqueue.c:

#include "linkqueue.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
LinkQueue *CreateLinkQueue()
{

    LinkQueue* lq = (LinkQueue*)malloc(sizeof(LinkQueue));
    if(NULL == lq)
    {
        perror("CreateLinkQueue malloc");
        return NULL;
    }
    lq->head = NULL;
    lq->tail = NULL;
    lq->clen = 0;
    return lq;

}
int DestroyLinkQueue(LinkQueue *queue)
{
    while(!IsEmptyLinkQueue(queue))
    {
        QuitLinkQueue(queue);
    }
    free(queue);
    return 0;
}
int QuitLinkQueue(LinkQueue *queue)
{
    if(IsEmptyLinkQueue(queue))
    {
        return 1;
    }
    QueueNode* tmp = queue ->head ;
    queue->head = queue->head->next ;
    free(tmp);
    queue->clen --;
    if(NULL == queue->head )
    {
        queue->tail = NULL;
    }
    return 0;
}
DATATYPE* GetHeadLinkQue(LinkQueue*queue)
{
    if(IsEmptyLinkQueue(queue))
    {
        return NULL;
    }
    return &queue->head->data;
}
int EnterLinkQueue(LinkQueue *queue, DATATYPE *data)
{
    QueueNode* newnode =(QueueNode*)malloc(sizeof(QueueNode));
    if(NULL == newnode)
    {
        perror("EnterLinkQueue malloc");
        return 1;
    }

    memcpy(&newnode->data,data,sizeof(DATATYPE));
    newnode->next = NULL;
    if(IsEmptyLinkQueue(queue))
    {
        queue->head = newnode;
        queue->tail = newnode;
    }
    else 
    {
        queue->tail->next = newnode;
        queue->tail = newnode;
    }

    queue->clen ++;
    return 0;


}
int IsEmptyLinkQueue(LinkQueue *queue)
{
    return 0 == queue->clen;
}

示例：

把指定目录 所有 遍历.h #define Log #define PI 3.14 24 filename 1.主线程：如果是文件，找#define，找到写文件 如果是目录，就入队 2.工作线程 如果是文件，找#define，找到写文件

#include "linkqueue.h"
#include <string.h>
#include <stdio.h>
#include <pthread.h>
#include <dirent.h>
#include <semaphore.h>
#define PATH "/home/linux/20240108"
pthread_t main_tid;
sem_t sem_task;
int check_file(char *path,FILE* log)
{

    printf("processing %s\n",path);
    FILE* fp = fopen(path,"r");
    if(NULL == fp)
    {
        perror("check_file fopen");
        return 1;
    }

    int num =1;
    while(1)
    {
        char buf[1024]={0};
        if(fgets(buf,sizeof(buf),fp))
        {
            if(strstr(buf,"#define"))
            {
                buf[strlen(buf)-1]='\0';
                fprintf(log,"%s %d %s\n",buf,num,path );
                fflush(log);
            
            }
        }
        else 
        {
            break;
        }
        num++;
    }
    fclose(fp);
    return 0;
}
int do_ls(char* path,FILE* log,LinkQueue*lq)
{

    DIR* dir = opendir(path);
    if(NULL == dir)
    {
        perror("opendir");
        return 1;
    }
    char newpath[512]={0};
    DATATYPE data;
    while(1)
    {
        bzero(newpath,sizeof(newpath));
        bzero(&data,sizeof(DATATYPE));
        struct dirent* info  = readdir(dir);
        if(NULL == info)
        {
            break;
        }
        
        sprintf(newpath,"%s/%s",path,info->d_name);
        if(DT_DIR == info->d_type)
        {
            if(0 == strcmp(info->d_name,".")
               || 0 == strcmp(info->d_name,".."))
            {
                continue;
            }
            if(main_tid == pthread_self())
            {
                strcpy(data.pathname,  newpath);
                EnterLinkQueue(lq,&data);
                sem_post(&sem_task);
            }
            else 
            {
                do_ls(newpath,log,lq);
            }

        }
        else 
        {
            check_file(newpath,log);

        }
    
    }
    closedir(dir);
    return 0;
}
typedef struct
{
    FILE* fp ;
    LinkQueue* lq;
}TH_ARG;
void* th(void* arg)
{
    TH_ARG *tmp = (TH_ARG*)arg;
    FILE* log = tmp->fp ;
    LinkQueue*lq = tmp->lq ;
    char path[512]={0};
    while(1)
    {
        bzero(path,sizeof(path));
        sem_wait(&sem_task);
        DATATYPE* ret = GetHeadLinkQue(lq);
        strcpy(path,ret->pathname);
        QuitLinkQueue(lq);
        if(0 == strcmp(path,"over"))
        {
            break;
        }
        do_ls(path,log,lq);
    }
    return NULL;
}
int main(int argc, char *argv[])
{
    main_tid=pthread_self();
    TH_ARG arg;
    bzero(&arg,sizeof(arg));
    LinkQueue* lq = CreateLinkQueue();
    FILE* log = fopen("log","w");
    if(NULL == log)
    {
        perror("fp");
        return 1;
    }
    arg.fp = log;
    arg.lq = lq;
    sem_init(&sem_task,0,0);
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,th,&arg);
    pthread_create(&tid2,NULL,th,&arg);
    pthread_create(&tid3,NULL,th,&arg);
    do_ls(PATH,log,lq);

    int i = 0 ;
    for(i =0;i<3;i++)
    {
        DATATYPE data;
        strcpy(data.pathname,"over");
        EnterLinkQueue(lq,&data);
        sem_post(&sem_task);
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    fclose(log);
    sem_destroy(&sem_task);
    DestroyLinkQueue(lq);
    return 0;
}

m0_65339175
关注
C语言实现链式队列
Future_LL的博客
03-05 1348
一、代码 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #define N 15 typedef struct { int data[N]; //队列数组； int head; //队头； int tail; //队尾； }SeqQueue; SeqQueue *SeqQ...
数据结构封装之《SeqQueue顺序式队列》
BeiJiaan的博客
08-29 1161
学习记录
队列的两种实现
如故的博客
04-08 254
顺序表实现队列 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; //顺序表实现队列 #define TEST_HEAD printf("\n=====%s=====\n", __FUNCTION__) #define DEFAULT_SZ 5 typedef char DataType; typedef struct seqQu...
c语言实现队列的顺序存储结构
hou19975418的博客
01-17 290
主要通过对顺序表两端的元素进行操作（队头队尾）来实现队列先进先出的功能。队列的顺序存储结构.c。
头歌-03 - 队列
爱睡觉的雨的博客
10-09 79
第一关 #include <stdio.h> #include <stdlib.h> #include "SeqQueue.h" SeqQueue* SQ_Create(int maxlen) // 创建顺序队列, 队列最多存储maxlen个队列元素。 { SeqQueue* sq=(SeqQueue*)malloc(sizeof(SeqQueue)); ...
经典数据结构队列的研究和实现.pdf
08-07
在数据结构的研究范畴内，队列是一种特别重要的线性数据结构，它遵循先进先出（First In First Out, FIFO）的原则。队列的概念源自日常生活中的排队等候，如商店结账或排队上公交车等。 队列的实现通常基于数组或...
数据结构队列用C语言描述.rar
08-07
总之，"数据结构队列用C语言描述"这个项目提供了一个学习和实践数据结构的好机会，不仅能够巩固C语言基础，还能深入理解数据结构的原理和应用。通过实际操作和调试代码，可以提升编程技能，为未来的IT职业生涯打下...
数据结构队列指针操作源代码
03-24
在创建数据结构队列时，我们可能需要一个包含元素存储空间、队头和队尾指针的结构体。例如： ```c typedef struct Queue { int data[MAX_SIZE]; // 假设MAX_SIZE是队列的最大容量 int front; // 队头指针 int ...
[详细完整版]数据结构队列.ppt
07-11
数据结构中的队列是一种线性数据结构，它遵循“先进先出”（FIFO）的原则，即最先插入的元素将是最先被删除的元素。队列通常被比喻为现实生活中排队等候的情况，如银行排队、餐厅点餐等，最早到达的人（元素）优先...
数据结构队列
02-12
本PPT介绍了数据结构的重要的部分，队列。而队列的应用则是非常重要
头歌数据结构与算法——队列
weixin_62440328的博客
10-25 7967
【代码】头歌数据结构与算法——队列。
顺序队列
早起的虫儿灬
04-01 294
#ifndef _SEQQUEUE_H_ #define _SEQQUEUE_H_ #include #include #define MAXSIZE 8 typedef int ElementType; typedef struct SeqQueue { ElementType *base;
数据结构：队列的顺序实现
顾道长生的科研笔记
08-09 350
听了国嵌唐老师的课，用C语言实现如下： SeqQueue.h #ifndef _SEQQUEUE_H_ #define _SEQQUEUE_H_ typedef void SeqQueue; SeqQueue* SeqQueue_Create(int capacity); void SeqQueue_Destroy(SeqQueue* queue); void SeqQueue_Clea...
C Primer Plus第四章编程练习
zhongshun0928的博客
04-21 255
1.编写一天程序，提示用户输入名和姓，然后以“名姓”的格式打印出来。 #include <stdio.h> #include <stdlib.h> int main() { char fname[40]; char lname[40]; printf("请输入你的名："); scanf("%s",lname); printf("请输...
线性表(List)---队列的顺序存储
StrugglingMice的博客
07-20 662
队列的顺序存储结构的设计与实现栈的介绍定义： 队列是一种特殊的线性表，队列仅在线性表的两端进行操作。 队头(Front)： 取出数据元素的一端。* 队尾(Rear)： 插入数据元素的一端。队列的常用操作 (1)创建队列 (2)销毁队列 (3)进队列 (4)出队列 (5)获取队列头部元素 (6)获取队列的长度队列顺序存储结构的设计队列的顺序存储模型     因为队列是一种特殊的线性表
数据结构顺序队列
qq_40995354的博客
04-15 281
对队列进行1.入队列2.出队列3.取队首元素队列先进先出，允许在一端进行插入操作，另一端进行删除操作。允许插入的一端称为队尾，允许删除的一端称为队首。我们head和tail标记队首和队尾。出队列时，将head向后移动，入队列时，将tail向后移动，再给tail赋值。为了方便判断队列是否满了，我们让head指向头部，tail指向队列最后一个元素的下一个位置，[head,tail)。tail移动到最后...
SeqQueue
_tree_
04-15 1366
注意由于模板的二次编译，最好让其实现放在头文件中，第一次编译在编译期就确定下来； SeqQueue.h template class SeqQueue{ public: SeqQueue(int sz) :m_nrear(0), m_nfront(0), m_ncount(0), m_nMaxSize(sz){ m_pelements = new Type[sz]; if
数据结构 队列 6
云中自有锦书
02-25 176
目录： 队列基本概念：常用操作 队列的顺序存储设计与实现 1）基本概念                      2）设计与实现 队列的链式存储设计与实现 1）基本概念                      2）设计与实现 总结回顾 1.队列基本概念 队列是一种特殊的线性表 队列仅在线性表的两端进行操作 队头(Front):取出数据元素的一端 队尾(Rear):插入数据元...
数据结构队列看病排队
最新发布
11-04
数据结构队列可以用来模拟看病排队的过程。队列是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。在看病排队的场景中，新来的病人会排在队列的末尾，而医生会从队列的头部开始依次处理病人。当一个病人被处理完后，他会从队列中被移除，而下一个病人则会成为队列的头部，等待医生的处理。 引用中提供了一个示例代码，其中使用了C++的STL库函数来实现队列的操作。具体来说，代码中首先包含了STL库函数的头文件，然后定义了一个结构体来表示病人的信息。接着，代码创建了一个队列，并通过循环向队列中添加病人。每当有一个病人被处理完后，代码会从队列中移除该病人，并输出他的信息。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值