精华内容
下载资源
问答
  • C语言队列创建

    千次阅读 2020-03-19 18:21:53
    数据结构之队列队列是另一种特殊的线性表,是先进先出的,并且出去的元素会被删除。就如同我们真实生活中排队一样,先到的人排在前面,也最先离开队列。...创建一个链表结构 typedef struct QueueNode { int da...

    数据结构之队列,队列是另一种特殊的线性表,是先进先出的,并且出去的元素会被删除。就如同我们真实生活中排队一样,先到的人排在前面,也最先离开队列。那么我们就来谈一下它的具体实现,这里主要使用链式存储方式。
    下面是代码

    #include<stdio.h>
    #include<stdlib.h>
    创建一个链表结构
    typedef struct QueueNode
    {
    	int data;
    	struct QueueNode *next;
    }QueueNode,*Queuelink;
    再创建一个队列结构
    typedef struct Queue
    {
    	Queuelink front, rear;//这里的首尾都是指针型的
    }Queue;
    //初始化队列
    void init(Queue *q)
    {
    //初始化为空并分配空间
    	q->front = q->rear = (Queuelink)malloc(sizeof(QueueNode));
    	if (!q->front)
    	{
    		exit(0);
    	}
    	//末尾指针指向空
    	q->front->next = NULL;
    }
    //入队操作,这里我们的队首节点并不存储值。
    void insert(Queue *q, int e)
    {
    	Queuelink p;
    	p = (Queuelink)malloc(sizeof(QueueNode));
    	if (p == NULL)
    		exit(0);
    	p->data = e;
    	//这部分和链表的尾插法一致
    	p->next = NULL;
    	q->rear->next = p;
    	q->rear = p;
    }
    //出队操作,其实就是单链表的操作
    void out(Queue *q, int *e)
    {
    	Queuelink p;
    	if (q->front == q->rear)
    	{
    		return;
    	}
    	p = q->front->next;
    	*e = p->data;
    	q->front->next = p->next;
    	if (q->rear == p)
    	{
    		q->rear = q->front;
    	}
    	free(p);
    }
    //判断是否为空
    int isempty(Queue *q)
    {
    	if (q->front == q->rear)
    		return 1;
    	else return 0;
    }
    
    展开全文
  • C语言实现队列

    千次阅读 2020-10-07 22:56:08
    C语言实现队列基本操作-初始化,入队,出队,打印,删除 C语言: #include <stdio.h> #include <stdlib.h> // 队列的实现 #define OVERFLOW -2 #define OK 1 #define ERROR 0 typedef int Status; ...

    C语言实现队列

    C语言:

    #include <stdio.h> 
    #include <stdlib.h>
    
    // 队列的实现
    #define OVERFLOW -2 
    #define OK 1
    #define ERROR 0
    
    typedef int Status;
    typedef int QElemType;
     
    typedef struct QNode{
    	QElemType data;
    	struct QNode * next;
    }QNode, *QueuePtr;
    typedef struct {
    	QueuePtr front;            // 队头指针 
    	QueuePtr rear;             // 队尾指针 
    }LinkQueue;
    
    Status InitQueue(LinkQueue &Q)
    {
    	// 构造一个空队列
    	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    	if(!Q.front) 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 EnQueue(LinkQueue &Q, QElemType e)
    {
    	// 插入元素 e 为 Q 的新的队列元素 
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    	if(!p) exit(OVERFLOW);          // 存储分配失败
    	p->data = e;
    	p->next = NULL;                // 队尾 next == NULL,有 data 
    	Q.rear->next = p;
    	Q.rear = p;                    // 更新队尾 
    	return OK; 
    }
    
    Status DeQueue(LinkQueue &Q, QElemType &e)
    {
    	// 若对头不空,则删除对头元素,用 e 返回其值,并返回 OK,否则返回 ERROR
    	if(Q.front == Q.rear) return ERROR;
    	QueuePtr p = Q.front->next;         // Q.front 没有 data, next != NULL(除非空队列) 
    	e = p->data;
    	Q.front->next = p->next;            // 更新队头 
    	if(Q.rear == p) Q.rear = Q.front;   // 队列为空了 
    	free(p);
    	return OK;
    }
    
    Status PrintQueue(LinkQueue Q)
    {
    	// 打印队列 Q 全部元素 
    	QueuePtr p = Q.front;
    	while(p->next){
    		printf("%d  ", p->next->data);
    		p = p->next;
    	}
    	printf("\n"); 
    }
    int main()
    {
    	LinkQueue q;
    	InitQueue(q);       // 初始化队列
    	
    	QElemType e1 = 666, e2 = 888;    // 向队列添加元素 
    	EnQueue(q, e1);
    	EnQueue(q, e2);
    	printf("队列元素:  "); 
    	PrintQueue(q);        // 打印队列 
    	
    	QElemType e3;
    	DeQueue(q, e3);
    	printf("删除元素为: %d \n", e3);
    	printf("队列元素:  "); 
    	PrintQueue(q);        // 打印队列 	
    	
    	DestroyQueue(q);      // 删除队列 
    	
    	return 0;
    }
    /* Code Running Results
    队列元素:  666  888
    删除元素为: 666
    队列元素:  888
    */
    

    栈和单链线性表基本操作实现:

    单链线性表

    展开全文
  • //退出程序 } Q->front=0; //初始化参数 Q->rear=0; return *Q; } /*********************************************** Function: Print the stack element; ************************************************...

    queue.h头文件

    #ifndef __QUEUE_H_
    #define __QUEUE_H_
    #include<stdio.h>
    #include<stdlib.h>
    #define maxsize 5
    typedef struct Data {
        int a;
        int b;
        int c;
    } Data;
    
    typedef struct queue {
        Data data[maxsize];
        int front;    //指向队列第一个元素
        int rear;     //指向队列最后一个元素的下一个元素
    } QUEUE, *PQUEUE;
    
    QUEUE CreateQueue();
    void TraverseQueue(PQUEUE Q);
    int FullQueue(PQUEUE Q);
    int EmptyQueue(PQUEUE Q);
    int Enqueue(PQUEUE Q, Data val);
    int Dequeue(PQUEUE Q, Data *val);
    #endif
    
    queue.c文件
    #include<stdio.h>
    #include<stdlib.h>
    #include"malloc.h"
    #include"queue.h"
    /***********************************************
    Function: Create a empty stack;
    ************************************************/
    QUEUE CreateQueue()
    {
        QUEUE *Q=(QUEUE *)malloc(sizeof(QUEUE));
        if(NULL==Q)
        {
            printf("Memory allocation failure");
            exit(-1);        //退出程序
        }
        Q->front=0;         //初始化参数
        Q->rear=0;
        return *Q;
    }
    
    /***********************************************
    Function: Print the stack element;
    ************************************************/
    void TraverseQueue(PQUEUE Q)
    {
        int i=Q->front;
        printf("队中的元素是:\n");
        while(i%maxsize!=Q->rear)
        {
            printf("%d ",Q->data[i]);
            i++;
        }
        printf("\n");
    }
    int FullQueue(PQUEUE Q)
    {
        if(Q->front==(Q->rear+1)%maxsize)    //判断循环链表是否满,留一个预留空间不用
            return 1;
        else
            return 0;
    }
    int EmptyQueue(PQUEUE Q)
    {
        if(Q->front==Q->rear)    //判断是否为空
            return 1;
        else
            return 0;
    }
    int Enqueue(PQUEUE Q, Data val)
    {
        if(FullQueue(Q))
            return 0;
        else
        {
            Q->data[Q->rear]=val;
            Q->rear=(Q->rear+1)%maxsize;
            return 1;
        }
    }
    
    int Dequeue(PQUEUE Q, Data *val)
    {
        if(EmptyQueue(Q))
        {
            return 0;
        }
        else
        {
            *val=Q->data[Q->front];
            Q->front=(Q->front+1)%maxsize;
            return 1;
        }
    }
    
    main.c文件

    #include <stdio.h>
    #include"queue.h"
    
    int main()
    {
        Data d={1,2,3};
        
        QUEUE Q=CreateQueue();
        
        Enqueue(&Q,d);
        d.a=2;
        Enqueue(&Q,d);
        Enqueue(&Q,d);
        Enqueue(&Q,d);
        Dequeue(&Q,&d);
        d.a=5;
        Enqueue(&Q,d);
        Dequeue(&Q,&d);
        d.a=6;
        Enqueue(&Q,d);
        Dequeue(&Q,&d);
        d.a=7;
        Enqueue(&Q,d);
        Dequeue(&Q,&d);
        Dequeue(&Q,&d);
        Dequeue(&Q,&d);
        printf("Hello World!\n");
        return 0;
    }
    



    展开全文
  • /*构造一个空队列*/ Queue *InitQueue() { Queue *pqueue = (Queue *)malloc(sizeof(Queue)); if(pqueue!=NULL) { pqueue->front = NULL; pqueue->rear = NULL; pqueue->size = 0; //pqueue->status=1; ...
    /*构造一个空队列*/
    Queue *InitQueue()  
    {
    	Queue *pqueue = (Queue *)malloc(sizeof(Queue));
    	if(pqueue!=NULL)
    	{
    		pqueue->front = NULL;
    		pqueue->rear = NULL;
    		pqueue->size = 0;
    		//pqueue->status=1;		//初始化为send数据
    	}
    	return pqueue;
    }
    
    /*销毁一个队列*/
    void DestroyQueue(Queue *pqueue)
    {
    	if(IsEmpty(pqueue)!=1)
    		ClearQueue(pqueue);
    	free(pqueue);
    }
    
    /*清空一个队列*/
    void ClearQueue(Queue *pqueue)
    {
    	while(IsEmpty(pqueue)!=1)
    	{
    		DeQueue(pqueue,NULL,NULL);
    	}
    
    }
    
    /*判断队列是否为空*/
    int IsEmpty(Queue *pqueue)
    {
    	if(pqueue->front==NULL&&pqueue->rear==NULL&&pqueue->size==0)
    		return 1;
    	else
    		return 0;
    }
    
    /*返回队列大小*/
    int GetSize(Queue *pqueue)
    {
    	return pqueue->size;
    }
    
    /*将新元素入队*/
    PNode EnQueue(Queue *pqueue,Item item,int sid)
    {
    	int length = 0;
    	PNode pnode = (PNode)malloc(sizeof(Node));
    	if(pnode != NULL)
    	{
    		// 这里一定要+1
    		length = strlen(item)*sizeof(char)+1;
    		//pnode->data = item;
    		pnode->data = (Item)malloc(length);
    		memset(pnode->data, 0, length);
    		memcpy(pnode->data, item, length);
    
    
    		pnode->next = NULL;
    		pnode->status = sid;
    		
    		if(IsEmpty(pqueue))
    		{
    			pqueue->front = pnode;
    		}
    		else
    		{
    			pqueue->rear->next = pnode;
    		}
    		pqueue->rear = pnode;
    		pqueue->size++;
    	}
    	return pnode;
    }
    
    /*队头元素出队*/
    PNode DeQueue(Queue *pqueue,Item pitem,int *sid)
    {
    	PNode pnode = pqueue->front;
    	if(IsEmpty(pqueue)!=1&&pnode!=NULL)
    	{
    		if(pitem!=NULL)
    		{
    			//*pitem = pnode->data;
    			memcpy(pitem, pnode->data, strlen(pnode->data));
    			free(pnode->data);
    
    			*sid = pnode->status;
    		}
    
    		pqueue->size--;
    		pqueue->front = pnode->next;
    		free(pnode);
    		if(pqueue->size==0)
    			pqueue->rear = NULL;
    	}
    	return pqueue->front;
    }
    
    
    /*遍历队列*/  
    void QueueTraverse(Queue* pqueue)  
    {  
    
    	PNode pnode = pqueue->front;  
    	int i = pqueue->size;  
    	while(i--)  
    	{  
      		printf("遍历队列第 %d 个元素 为: %s\n", i, pnode->data);
    		pnode = pnode->next;  
    	}  
    }  



    头文件

    #ifndef Queue_H
    #define Queue_H
    
    typedef char* Item;
    typedef struct node * PNode;
    typedef struct node
    {
    	Item data;
    	PNode next;
    	int status;		//status=1 表明是send 数据,=2为recv数据
    }Node;
    
    typedef struct
    {
    	PNode front;
    	PNode rear;
    	int size;
    }Queue;
    
    /*构造一个空队列*/
    Queue *InitQueue(); 
    
    /*销毁一个队列*/
    void DestroyQueue(Queue *pqueue);
    
    /*清空一个队列*/
    void ClearQueue(Queue *pqueue);
    
    /*判断队列是否为空*/
    int IsEmpty(Queue *pqueue);
    
    /*返回队列大小*/
    int GetSize(Queue *pqueue);
    
    /*将新元素入队*/
    PNode EnQueue(Queue *pqueue,Item item,int sid);
    
    /*队头元素出队*/
    PNode DeQueue(Queue *pqueue,Item pitem,int *sid);
    
    /*遍历队列,并对各项数据调用visit函数*/  
    void QueueTraverse(Queue* pqueue); 
    
    #endif
    


    展开全文
  • C语言实现循环队列

    2019-11-16 14:09:51
    通过C语言实现顺序循环队列和链式队列思想解读 1:链式循环队列思想 总的来说和顺序循环队列是一样的, 1:我们需要首先定义一个数据的结构体 struct link_data { int data; struct link_data *next; } 2:再定义...
  • C语言实现队列Queue

    千次阅读 2017-08-07 17:05:43
    文章来源:... ...  还是先放这张图,以便对比和理解: ... 队列是限制在两端进行插入操作和删除操作的线性表,允许进行存入操作的一端称为“队尾”,允许进行删除操作的一端称为
  • C语言实现顺序队列

    千次阅读 2020-06-24 12:51:10
    C语言详解顺序队列
  • 消息队列就是由内核负责管理的一个管道,...功能:创建/获取消息队列 key:IPC键值,由ftok函数自动生成 msgflg: 0 获取消息队列 IPC_CREAT 创建消息队列 IPC_EXCL 如果存在则创建失败 返回值:消息队列标识 in...
  • c语言经典案例

    2014-10-30 08:06:57
    实例001 第一个C语言程序 2 实例002 一个完整的C语言程序 2 实例003 输出名言 3 实例004 用TC 2.0打开文件 4 实例005 计算正方形的周长 5 第2章 简单的C程序 6 实例006 输出一个正方形 7 实例007 输出一个三角形 8 ...
  • # 下面给出的代码是循环队列的基础操作,代码注释写的还算详细,帮助大家理解,同时也有助我回忆 在这里插入代码片 #include<stdio.h> #define qsize 5 int qdata[5],i=0; struct cell///单个结点 { int data;...
  • C语言实现一种缓冲队列源码 源码 这里采用的是一块二维数组作为缓冲区,每一行可以存储 MAX_ITEM_LEN 个数据,一共可以存储 MAX_ITEM 行数据。 #define MAX_ITEM 20 #define MAX_ITEM_LEN 51 unsigned char tx_buf...
  • c语言实现队列的先进先出操作

    千次阅读 2020-01-07 22:24:45
    队列的特点是先进先出,有一个队列头和一个队列尾。如下图示:整个队列含有一个队列头指针front和一个队列尾指针rear,并且队列中每个节点中包含一个数据域和一个指向下一个节点的指针域。 定义一个节点: ...
  • 队列(C语言简单实现)

    2020-10-16 15:16:40
    队列(C语言) 本文参考自《大话数据结构》 定义 ​ 队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表,简称FIFO(First In First Out),允许插入的一端称为队尾,允许删除的一端称为队头。 ...
  • C语言 环形队列

    千次阅读 2016-08-15 16:41:44
    队列队列是一种先进先出的数据结构。比如说 排队买票,有一个售票口,最多能排30人,那么最大存储空间就是30人,每当有1个新人过来排队,就会站在队尾,这就叫入队,每当有1个人买到票了,就会离开,就叫出队。...
  • 循环队列就是队列首尾相连,容量固定的环 对于循环队列 需要判断当前是否队列可以插入 也就是队是否满了 通常有以下三种方法判断 设置一个标志位表示栈空或满 设置一个插入元素个数计数器 采用余数法 对每次插入的...
  • C语言 消息队列

    万次阅读 2014-03-08 21:30:17
    消息队列(也叫做报文队列)能够克服早期unix通信机制的一些缺点。作为早期unix通信机制之一的信号能够传送的信息量有限,后来虽然POSIX 1003.1b在信号的实时性方面作了拓广,使得信号在传递信息量方面有了相当程度...
  • c语言中优先级队列A Priority Queue is a variant of a Queue such that it’s elements are ordered based on their priority. C++ has a built-in priority queue data structure in it’s Standard Template ...
  • C语言实现链式队列

    2020-03-01 19:21:12
    链式队列的实现思想同顺序队列类似,只需创建两个指针(命名为 top 和 rear)分别指向链表中队列的队头元素和队尾元素,如下图所示: 所示为链式队列的初始状态,此时队列中没有存储任何数据元素,因此 top 和 ...
  • C语言

    万次阅读 多人点赞 2019-12-18 23:01:50
    46.用c语言编写程序,可以编写出任何类型的程序 47.C语言允许有空函数 48.C程序书写格式,允许一行内可以写几个语句 49.C程序的语句无行号 50.C语言的每个语句的最后必须有一个分号 51.C语言本身没有输入...
  • C语言实现链表、堆栈和队列

    千次阅读 2019-12-13 09:02:14
    通过C语言实现单向链表、有序链表、循环链表、数组堆栈、链式堆栈以及对了,并且给出了一种堆栈的面向对象形式。
  • C语言实现动态数组队列
  • C语言实现顺序队列(循环队列)的常用操作,包括初始化顺序队,创建顺序队,入队,出队,计算队的长度,清空队列等等
  • 在哔哩哔哩看视频学的,赫斌老师数据结构入门的内容-b站搜索:av6159200(P47),通过学习循环队列,能独立把赫斌老师教的敲出来,并且自己摸索着实现链式队列. 第三部分最后面有我链式队列的ppt图解下载 二.什么是队列 ...
  • c语言创建一个窗口

    万次阅读 多人点赞 2017-12-04 01:23:35
    c语言创建一个窗口,环境为vs2010
  • 本文借助easyx库函数(提供下载链接),很方便地用C语言实现了鼠标、按钮、进度条、坐标尺等操作,为普通C程序的友好人机交互界面提供了一种简单便捷的方案。
  • 摘要: 在一次数据结构实验课上,老师提出了使用队列实现杨辉...但作者在文章中并没有写出实现步骤,下面我就以c语言循环队列去实现这个算法. 算法参考来源: https://zhuanlan.zhihu.com/p/89667145 1.算法分析: 程序分析
  • C语言实现 多线程互斥访问消息队列程序中有一个应用消息队列,一个内核消息队列,3个线程,其中两个线程实现对应用消息队列的互斥访问,主要是运用互斥子操作

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,516
精华内容 15,006
关键字:

c语言创建队列程序

c语言 订阅