精华内容
下载资源
问答
  • 队列基本操作(c语言版)#include#includetypedef int elemType;struct QueuePtr{elemType data;struct QueuePtr *next;};struct LinkQueue{struct QueuePtr *front;struct QueuePtr *rear;};void initQueue(struct ...

    队列的基本操作(c语言版)

    #include

    #include

    typedef int elemType;

    struct QueuePtr{

    elemType data;

    struct QueuePtr *next;

    };

    struct LinkQueue{

    struct QueuePtr *front;

    struct QueuePtr *rear;

    };

    void initQueue(struct LinkQueue *Q)

    /*第一个操作构造一个空队列q*/

    {

    Q->front = Q->rear = NULL;

    /* 把队首和队尾指针置空 */

    return;

    }

    void push(struct LinkQueue *Q, elemType x)

    /*第二个操作插入元素e为q的新的队尾元素 */

    {

    /* 得到一个由newP指针所指向的新结点 */

    struct QueuePtr *newP;

    newP = (struct QueuePtr*)malloc(sizeof(struct QueuePtr));

    if(newP == NULL){

    printf("内存空间分配失败! ");

    exit(1);

    }

    /* 把x的值赋给新结点的值域,把新结点的指针域置空 */

    newP->data = x;

    newP->next = NULL;

    /* 若链队为空,则新结点即是队首结点又是队尾结点 */

    if(Q->rear == NULL){

    Q->front = Q->rear = newP;

    }

    else{

    /* 若链队非空,则依次修改队尾结点的指针域和队尾指针,使之指向新的队尾结点 */

    Q->rear = Q->rear->next = newP;

    /*可以分两句话来写*/

    }

    }

    elemType pop(struct LinkQueue *Q)

    /*第三个操作队列不为空,则删除q的队头元素,用e返回其值,并返回ok; */

    {

    struct QueuePtr *p;

    elemType temp;

    /* 若链队为空则停止运行 */

    if(Q->front == NULL){

    printf("队列为空,无法删除! ");

    exit(1);

    }

    temp = Q->front->data;

    /* 暂存队尾元素以便返回 */

    p = Q->front;

    展开全文
  • c语言队列基本操作代码

    千次阅读 2014-03-22 22:15:26
    为了打印binary tree,要使用队列,所以先写个程序测试下 #include #include typedef struct _node { int value; struct _node *next; }Node; typedef struct _Queue { Node *head; Node *tail; }Queue; ...

    为了打印binary tree,要使用队列,所以先写个测试程序.

    总结下经验:

    1.队列结构Queue只是一个容器,两个指针表示头和尾。

    2.要注意区分head和tail的三种情况的处理:NULL,只有一个节点,多个节点。

    3.测试时候,node没有free,我试过在for里面free,会导致传到enQueue中node也被free,以后还要研究怎么正确地free。

    4.Queue是容器,只需要init一次,而node有多个,所以每个node都要调用init_node,其主要操作是使用malloc函数分配空间。

    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct _node
    {
       int value;
       struct _node *next;
    }Node;
    
    typedef struct _Queue
    {
       Node *head;
       Node *tail;
    }Queue;
    
    Queue* init_queue()
    {
       Queue *queue=(Queue*)malloc(sizeof(Queue));
       queue->head = queue->tail = NULL;
       return queue;
    }
    
    int enQueue(Queue *pQueue,Node *pNode)
    {
          if(pQueue->head == NULL)
          {//when it's empty
               pQueue->head = pNode; 
    	   pQueue->tail = pNode;     
          }    
          else
          {
               pQueue->tail->next = pNode;
    	   pQueue->tail = pNode;
          }
    }
    
    Node* deQueue(Queue *pQueue)
    {
    	if(pQueue->head == NULL)
    	{
    	   return NULL;
    	}
    
    	Node *deNode= pQueue->head;
    	pQueue->head = pQueue->head->next;  
            return deNode;
    }
    
    Node* init_node(int value)
    {
        Node  *new_node = (Node*)malloc(sizeof(Node));
        new_node->value=value;
        return new_node;
    }
    
    //0:empty
    int ifEmpty(Queue *pQueue)
    {
       if(pQueue->head == NULL)
       {
         printf("empty tree\n");
         return 0;
       }
       
       printf("queue is not empty\n");
       return 1;
    }
    
    int main()
    {
      Queue *queue=init_queue();
      int i;
    
      ifEmpty(queue);
      printf("insert node to queue\n");
      for(i=1; i<7;i++)
      {
       Node *node = init_node(i);
       enQueue(queue,node);
      // free(node);
      }
      
    //  Node *node = init_node(1);
    //  printf("node->value = %d\n",node->value);
    //  enQueue(queue,node);
      ifEmpty(queue);
      
      for(i=0;i<7;i++)
      {
    	  Node *deNode = deQueue(queue);
    	  if(deNode==NULL)
    	  {
    	     printf("NULL\n");
    	  }
    	  else
    	  {
    	     printf("deNode->value = %d\n",deNode->value);
    	  }
    	  
      }
      free(queue);
      return 0;
    }

    展开全文
  • C语言队列基本操作

    2016-02-20 20:18:10
    C语言队列基本操作 入队 出队 对的初始化
  • C语言队列基本操作 #include <stdio.h> #include <stdlib.h> #include <malloc.h> /* C语言队列基本操作 2014年7月11日10:11:41 */ typedef int qType; typedef struct node ...

    C语言链队列基本操作

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    /*
        C语言链队列基本操作
        2014年7月11日10:11:41
    */
    typedef int qType;
    typedef struct node
    {
        qType data;
        struct node *pNext;
    }Node,*pNode;
    typedef struct queue
    {
        pNode front;
        pNode rear;
    }linkQ,*pLinkQ;
    
    //初始化队列
    void initQueue(linkQ *);
    //入队
    void enQueue(linkQ *,qType);
    //出队
    void deQueue(linkQ *,qType *);
    
    
    int main()
    {
        linkQ q;
        qType data,reval;
        int i;
        initQueue(&q);
        printf("请输入5个整数:");
        for(i=0; i<5; i++)
        {
            scanf("%d",&data);
            enQueue(&q,data);
        }
        printf("\n输出结果为:");
        while(q.front != q.rear)
        {
            deQueue(&q,&reval);
            printf("%d ", reval);
        }
        printf("\n");
        return 0;
    }
    
    void initQueue(linkQ * q)
    {
        q->front = q->rear = (pNode)malloc(sizeof(Node));
        if(!q->front)
        {
            exit(-1);
        }
        q->front->pNext = NULL;
        return ;
    }
    void enQueue(linkQ * q,qType data)
    {
        pNode pNew;
        pNew = (pNode)malloc(sizeof(Node));
        if(!pNew)
        {
            exit(-1);
        }
        pNew->data = data;
        pNew->pNext = NULL;
        q->rear->pNext = pNew;
        q->rear = pNew;
        return ;
    }
    void deQueue(linkQ * q,qType *val)
    {
        pNode pNew;
        if(q->front == q->rear)
        {
            exit(-1);
        }
        pNew = q->front->pNext;
        *val = pNew->data;
        q->front->pNext = pNew->pNext;
        if(q->rear == pNew)
        {
            q->rear = q->front;
        }
        free(pNew);
        return ;
    }
    View Code

     代码二

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    /*
        C语言链队列基本操作
        2014年7月11日10:11:41
    */
    typedef int qType;
    typedef struct node
    {
        qType data;
        struct node *pNext;
    }Node,*pNode;
    typedef struct queue
    {
        pNode front;
        pNode rear;
    }linkQ,*pLinkQ;
    
    //初始化队列
    void initQueue(pLinkQ);
    //入队
    void enQueue(pLinkQ,qType);
    //出队
    void deQueue(pLinkQ,qType *);
    
    
    int main()
    {
        linkQ q;
        qType data,reval;
        int i;
        initQueue(&q);
        printf("请输入5个整数:");
        for(i=0; i<5; i++)
        {
            scanf("%d",&data);
            enQueue(&q,data);
        }
        printf("\n输出结果为:");
        while(q.front != q.rear)
        {
            deQueue(&q,&reval);
            printf("%d ", reval);
        }
        printf("\n");
        return 0;
    }
    
    void initQueue(pLinkQ q)
    {
        q->front = q->rear = (pNode)malloc(sizeof(Node));
        if(!q->front)
        {
            exit(-1);
        }
        q->front->pNext = NULL;
        return ;
    }
    void enQueue(pLinkQ q,qType data)
    {
        pNode pNew;
        pNew = (pNode)malloc(sizeof(Node));
        if(!pNew)
        {
            exit(-1);
        }
        pNew->data = data;
        pNew->pNext = NULL;
        q->rear->pNext = pNew;
        q->rear = pNew;
        return ;
    }
    void deQueue(pLinkQ q,qType *val)
    {
        pNode pNew;
        if(q->front == q->rear)
        {
            exit(-1);
        }
        pNew = q->front->pNext;
        *val = pNew->data;
        q->front->pNext = pNew->pNext;
        if(q->rear == pNew)
        {
            q->rear = q->front;
        }
        free(pNew);
        return ;
    }
    View Code

     

    转载于:https://www.cnblogs.com/kingshow123/p/queue.html

    展开全文
  • 【数据结构严蔚敏】 第三章 队列基本操作C语言 队列基本操作与栈类似,区别是删除元素时根据先进先出原则(FIFO),下面给出链队列的基本操作。 代码部分 1.基本结构定义 typedef int QElemType; //元素类型 ...

    【数据结构严蔚敏】 第三章 队列基本操作C语言

    队列基本操作与栈类似,区别是删除元素时根据先进先出原则(FIFO),下面给出链队列的基本操作。

    代码部分

    1.基本结构定义

    typedef int QElemType;	//元素类型
    typedef int Status;		
    typedef struct QNode {
    	QElemType data;
    	struct QNode *next;
    }QNode,*QueuePtr;
    
    typedef	struct {
    	QueuePtr front;	//对头指针
    	QueuePtr rear;	//队尾指针
    }LinkQueue;
    

    2.基本操作函数声明 LinkQueue.h

    //构造一个空队列
    Status InitQueue(LinkQueue &Q);
    
    //销毁队列Q,Q不再存在
    Status DetroyQueue(LinkQueue &Q);
    
    //将Q清为空队列
    Status ClearQueue(LinkQueue &Q);
    
    //若Q为空队列,则返回TRUE,否则返回FLASE
    Status QueueEmpty(LinkQueue Q);
    
    //返回Q的元素个数
    int QueueLenth(LinkQueue Q);
    
    //若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR
    Status GetHead(LinkQueue Q, QElemType &e);
    
    //插入元素e为Q的新的队尾元素
    Status EnQueue(LinkQueue &Q, QElemType e);
    
    //若队列不空,则删除Q的队头元素,用e返回其值,并返回OK
    Status DeQueue(LinkQueue &Q, QElemType &e);
    
    //对队列所有元素依次进行visit()操作
    Status QueueTraverse(LinkQueue Q, Status(*visit)(QueuePtr));
    

    3.基本操作函数定义 LinkQueue.c

    #include "LinkQueue.h"
    
    Status InitQueue(LinkQueue & Q)
    {
    	//构造一个空队列Q
    	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    	if (!Q.front)exit(OVERFLOW);
    	Q.front->next = NULL;
    	return OK;
    }
    
    Status DetroyQueue(LinkQueue & Q)
    {
    	//销毁一个队列
    	while (Q.front) {
    		Q.rear = Q.front->next;
    		free(Q.front);
    		Q.front = Q.rear;
    	}
    	return OK;
    }
    
    Status ClearQueue(LinkQueue & Q)
    {	//清除一个队列
    	while (Q.front->next) {
    		Q.rear = Q.front->next;
    		free(Q.front);
    		Q.front = Q.rear;
    	}
    	Q.front->next = NULL;
    	return OK;
    }
    
    Status QueueEmpty(LinkQueue Q)
    {	//判断队列是否为空
    	if (Q.front == Q.rear) return TRUE; 
    	return FALSE;
    }
    
    int QueueLenth(LinkQueue Q)
    {	//返回队列长度	
    	QueuePtr p;
    	p = Q.front;
    	int i=0;
    	while (!(p==Q.rear)) {
    		i++;
    		p = p->next;
    	}
    	return i;
    }
    
    Status GetHead(LinkQueue Q, QElemType & e)
    {
    	//
    	if (Q.front == Q.rear)return ERROR;
    	e = Q.front->next->data;
    	return OK;
    }
    
    Status EnQueue(LinkQueue & Q, QElemType e)
    {	//插入元素e为Q的新的队尾元素
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    	if (!p)return ERROR;
    	p->next = NULL;
    	p->data = e;
    	Q.rear->next = p;
    	Q.rear = p;
    	return OK;
    }
    
    Status DeQueue(LinkQueue & Q, QElemType & e)
    {//若队列不空,则删除Q的队头元素,用e返回其值,并返回OK
    	if (Q.front == Q.rear)return ERROR;
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));   //此处为何要给p申请空间?
    	p = Q.front->next;								//Q.front->next已经申请过内存空间
    	e = p->data;									//p = Q.front->next之后
    	Q.front->next = p->next;						//free(p)free的是哪一块?
    	if (Q.rear == p)Q.rear = Q.front;
    	free(p);
    	return OK;
    }
    
    Status QueueTraverse(LinkQueue Q, Status(*visit)(QueuePtr))
    {
    	QueuePtr p;
    	p = Q.front;
    	while (p->next)
    	{
    		p = p->next;
    		if (!(visit(p)))return ERROR;
    	}
    	return OK;
    }
    

    4.测试

    #include"LinkQueue.h"
    int visit(QueuePtr p) {
    	//visit函数用来输出队列
    	cout << p->data<<" ";
    	return OK;
    }
    int main() {
    	LinkQueue Q;
    	InitQueue(Q);
    	cout << "空队列初始化成功" << endl;
    	cout << "在队列中依次插入五个元素" << endl;
    	QElemType e;
    	for (int i = 0; i < 5; i++)
    	{
    		cin >> e;
    		EnQueue(Q, e);
    	}
    	cout << "输出整个队列" << endl;
    	QueueTraverse(Q,visit);
    	DeQueue(Q, e);
    	cout << endl;
    	cout << "删除队头元素,输出整个队列" << endl;
    	QueueTraverse(Q, visit);
    	cout << endl<<"清空队列" << endl;
    	ClearQueue(Q);
    	cout << "输出整个队列" << endl;
    	QueueTraverse(Q, visit);
    	cout << endl << "销毁队列,结束" << endl;
    	DetroyQueue(Q);
    	system("pause");
    	return 0;
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • C语言实现环形队列基本操作(以简单排队问题为例) 通过调用简单函数实现顺序表的相关操作。代码编译环境为VS2019 16.9.4。因为VS的某些原因,scanf写为了scanf_s,作用是一样的,在其他编译环境中可将scanf_s改回去...
  • [C语言]队列基本操作

    千次阅读 2012-08-02 12:55:57
    #include typedef struct dataNode { int data; struct dataNode *next; }qNode; typedef struct linkQueue { qNode *head; qNode *tail;...//创建一个新队列 linkQueue* createLinkQueue()
  • 实验三 队列 一、实验目的 1.深入了解队列的定义和特性。...顺序队列基本操作的实现(初始化、赋值、取值、插入、删除等)。 循环队列源程序 #include<stdio.h> //#include<stdlib.h> #inc...
  • 队列比较简单,与顺序栈的区别就是先进先出 代码可编译运行 //Init 初始化 //In 入队 //Out 出队 //Print 打印 //Length 求队-长 #include<stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef...
  • 文章首发于 2020-10-15 知乎文章:数据结构(C语言)-循环队列基本操作 作者:落雨湿红尘(也是我o) 01.队列介绍 队列是一种先进先出(first in first out,FIFO)的线性表,是一种常用的数据结构。 它只允许在表的...
  • 文章首发于2020-10-15 知乎文章:数据结构(C语言)-链队列基本操作 作者:落雨湿红尘(也就是我o) 01.队列介绍 队列是一种先进先出(first in first out,FIFO)的线性表,是一种常用的数据结构。 它只允许在表...
  • C语言队列

    2016-01-18 21:06:03
    队列 队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是...//---------队列基本结构--------- struct Node //结点结构体 { DataT
  • 源代码 #include <stdio.h> #include <stdlib.h>... printf("\n队列为空!\n\n"); }else{ printf("队列中元素如下:\n"); int i; if(front < rear){ for(i=front; i<rea
  • 队列基本操作实现队列链队的定义及其基本操作1、队列的定义队列,简称队,它是一种操作受限的线性表,其限制在表的一端进行插入,另一端进行删除。可进行插入的一端称为队尾(rear),可进行删除的一端称为队头(front...
  • 双端队列的定义:可以在两端做插入和删除操作队列就叫做双端队列 一般来说,双端队列用循环数组来实现。 push 将元素插入表头 front- - pop 删除头部元素 front++ inject 将元素插入到表尾 rear++ eject 删除尾部...
  • 队列基本操作-C语言

    2017-11-20 21:17:53
    #include #include <stdlib.h>/* 队列 */typedef struct Node{ int data; struct Node *next; }Node,*PNode;typedef struct Queue{ PNode front; PNode rear; }Queue, *PQueue;//初始化队列 PQue
  • 初始化队列队列队列 返回对头元素 返回队尾元素 计算队列长度 判断队列是否为空,为空返回1,否则返回零 1、初始化队列 void QueueInit (Queue* q) //初始化队列 { ...
  • 队列有普通顺序队列、循环队列以及链式队列,顺序队列会出现空间的使用不科学、虚假溢出等问题,链式队列相对简单,故这里实现循环队列,重点在于各个判断的条件。 #include <stdio.h> #include <stdlib.h&...
  • C语言实现对队列基本操作

    万次阅读 2018-01-29 18:48:52
    C语言实现对队列基本操作 代码思想: (1)定义循环队列:rear指针指向队列的最后一个元素所在位置,front指针则指向第一个元素的前一个位置。并且rear和front都只能单方向移动。 (2)入队操作:先判断队列...
  • void SqQueueout(SqQueue &Q,QElemtype &e) { if(Q.front==Q.real) { printf("队空"); exit(0); } e=Q.base[Q.front]; Q.front=(Q.front+1)%maxsize; }
  • C语言 算法与数据结构 链队列 基本操作及案例 实验要求: 实现链队列的判空、入队、出队、获取队首元素的基本操作。 main.c #include"LinkQueue.c" int main() { system("color f5"); system("title 链队列基本...
  • 队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出的规则FIFO(First In First Out) 入队列:进行插入操作的一端称为队尾 出队列:进行删除操作的一端称为队头 其实队列...
  • C语言队列基本操作实现

    千次阅读 2018-04-09 14:31:51
    本次以顺序队列和链式队列的方法实现队列基本操作基本操作:初始化,销毁,入队列,出队列,取队头元素顺序队列:listqueue.h#include&lt;stdio.h&gt;typedef char ListQueueType;#define MaxSize 1000...
  • 循环队列:把头尾相接的顺序存储结构称为循环队列
  • C语言实现 队列基本操作+

    千次阅读 2018-02-07 16:27:48
    队列的定义及基本运算 栈是一种后进先出的数据结构,在实际问题中还经常使用一种“先进先出”的数据结构: 即插入在表一端进行,而删除在表的另一端进行,将这种数据结构称为队或队列,把允许插 入的一端叫队尾...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,002
精华内容 16,400
关键字:

c语言队列的基本操作

c语言 订阅