队列的基本运算（顺序，环形，链式）

hi！AaA

于 2024-08-02 22:36:07 发布

阅读量210

点赞数 3

文章标签：数据结构

本文链接：https://blog.csdn.net/2202_75519246/article/details/140881559

版权

以下分别介绍了顺序队列，环形队列，链式队列的基本运算。主要有五种基本运算：1.初始化队列，2.销毁队列，3.判断队列是否为空，4.进队列，5.出队。

顺序队列

环形队列

链式队列

顺序队列与环形队列的基本运算大体上都一致，只是在队满或队空时判断条件有所差异。

顺序队列

#include <stdio.h>   
#include <malloc.h>  
//顺序队中实现队列的基本运算********************************************************8 
#define MaxSize 5  
typedef char ElemType;  
typedef struct  
{  
    ElemType data[MaxSize];  
    int front,rear;     /*队首和队尾指针*/  
} SqQueue;  

//初始化顺序队列 
void InitQueue(SqQueue *&q)   
{  
    q=(SqQueue *)malloc (sizeof(SqQueue));  
    q->front=q->rear=-1;  
}  

 //销毁顺序队列 
void DestroyQueue(SqQueue *&q) 
{  
    free(q);  
}  

//判断顺序队列是否为空  
bool QueueEmpty(SqQueue *q)  
{  
    return(q->front==q->rear);  
}  
  
//返回队列中元素个数，也称队列长度  
int QueueLength(SqQueue *q)  
{  
    return (q->rear-q->front);  
}  
  
 //进队列 
bool enQueue(SqQueue *&q,ElemType e)   
{  
    if ((q->rear+1)%MaxSize==q->front)  //队满上溢出  
        return false;  
    q->rear++; 
    q->data[q->rear]=e;  
    return true;  
}  

//出队列 
bool deQueue(SqQueue *&q,ElemType &e)  
{  
    if (q->front==q->rear)      //队空下溢出  
        return false;  
    q->front++;
    e=q->data[q->front];  
    return true;  
}  

int main()  
{  
    ElemType e;  
    SqQueue *q;  
    printf("(1)初始化队列q\n");  
    InitQueue(q);  
    printf("(2)依次进队列元素a,b,c\n");  
    if (enQueue(q,'a')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'b')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'c')==0) printf("队满,不能进队\n");  
    printf("(3)队列为%s\n",(QueueEmpty(q)?"空":"非空"));  
    if (deQueue(q,e)==0)  
        printf("队空,不能出队\n");  
    else  
        printf("(4)出队一个元素%c\n",e);  
    printf("(5)队列q的元素个数:%d\n",QueueLength(q));  
    printf("(6)依次进队列元素d,e,f\n");  
    if (enQueue(q,'d')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'e')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'f')==0) printf("队满,不能进队\n");  
    printf("(7)队列q的元素个数:%d\n",QueueLength(q));  
    printf("(8)出队列序列:");  
    while (!QueueEmpty(q))  
    {  
        deQueue(q,e);  
        printf("%c ",e);  
    }  
    printf("\n");  
    printf("(9)释放队列\n");  
    DestroyQueue(q);  
    return 0;  
    }

环形队列

#include <stdio.h>   
#include <malloc.h>  
//环形队中实现队列的基本运算********************************************************8 
#define MaxSize 5  
typedef char ElemType;  
typedef struct  
{  
    ElemType data[MaxSize];  
    int front,rear;     /*队首和队尾指针*/  
} SqQueue;  

//初始化环形队列 
void InitQueue(SqQueue *&q)   
{  
    q=(SqQueue *)malloc (sizeof(SqQueue));  
    q->front=q->rear=0;  
}  

 //销毁环形队列 
void DestroyQueue(SqQueue *&q) 
{  
    free(q);  
}  

//判断环形队列是否为空  
bool QueueEmpty(SqQueue *q)  
{  
    return(q->front==q->rear);  
}  
  
//返回队列中元素个数，也称队列长度  
int QueueLength(SqQueue *q)  
{  
    return (q->rear-q->front);  
}  
  
 //进队列 
bool enQueue(SqQueue *&q,ElemType e)   
{  
    if ((q->rear+1)%MaxSize==q->front)  //队满上溢出  
        return false;  
    q->rear=(q->rear+1)%MaxSize;
    q->data[q->rear]=e;  
    return true;  
}  

//出队列 
bool deQueue(SqQueue *&q,ElemType &e)  
{  
    if (q->front==q->rear)      //队空下溢出  
        return false;  
    q->front=(q->front+1)%MaxSize; 
    e=q->data[q->front];  
    return true;  
}  

int main()  
{  
    ElemType e;  
    SqQueue *q;  
    printf("(1)初始化队列q\n");  
    InitQueue(q);  
    printf("(2)依次进队列元素a,b,c\n");  
    if (enQueue(q,'a')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'b')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'c')==0) printf("队满,不能进队\n");  
    printf("(3)队列为%s\n",(QueueEmpty(q)?"空":"非空"));  
    if (deQueue(q,e)==0)  
        printf("队空,不能出队\n");  
    else  
        printf("(4)出队一个元素%c\n",e);  
    printf("(5)队列q的元素个数:%d\n",QueueLength(q));  
    printf("(6)依次进队列元素d,e,f\n");  
    if (enQueue(q,'d')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'e')==0) printf("队满,不能进队\n");  
    if (enQueue(q,'f')==0) printf("队满,不能进队\n");  
    printf("(7)队列q的元素个数:%d\n",QueueLength(q));  
    printf("(8)出队列序列:");  
    while (!QueueEmpty(q))  
    {  
        deQueue(q,e);  
        printf("%c ",e);  
    }  
    printf("\n");  
    printf("(9)释放队列\n");  
    DestroyQueue(q);  
    return 0;  
    }

链式队列

#include <stdio.h>
#include <malloc.h>
typedef char ElemType;  
//定义结构类型 
typedef struct qnode
{
    ElemType data;
    struct qnode*next;
}DateNode;
//创建一个虚拟首节点和尾节点 
typedef struct
{
    DateNode *front;
    DateNode *rear;
}LinkQueue;

//初始化队列 
void InitQueue(LinkQueue *&q)
{
    //链队头结点申请空间
    q = (LinkQueue *)malloc(sizeof(LinkQueue));
    //队首尾指针置空
    q->front = q->rear =NULL;
}


 //销毁队列 
void DestroyQueue(LinkQueue *&q)		//逐一消除，从首节点到尾 ，最后释放头结点 
{
	DateNode *pre = q->front;
	DateNode *p;
	//先判断链队是否为空,为空无需删除数据节点 ,直接释链队头结点q即可
	if(pre!=NULL)
	{
		p=pre->next;
		while(p!=NULL)
		{
			//当我们要删除的节点后无节点
			free(p);
			pre=p;
			p= p->next;
		}
		free(pre);
	}
	free(q);				//释放链队头结点 
}

//判断队列是否为空 
bool QueueEmpty(LinkQueue *q)
{
    return(q->rear==NULL);
}

//进队列 
void enQueue(LinkQueue *&q,ElemType e)
{
    //为新元素创建链表节点
    DateNode *p;
    p = (DateNode *)malloc(sizeof(DateNode));
    p->data = e;
    //因为新节点作为尾结点,所以后继指针置空
    p->next = NULL;
    //插入前,先判断队列是否为空,如果为空,则新元素作为唯一一个节点,
    //队首指针和队尾指针都指向这个节点
    if(q->rear == NULL)
    {
        q->front = q->rear = p;
    }
    else
    {
        q->rear->next = p;
        q->rear = p;
    }
 
}

bool deQueue(LinkQueue*&q,ElemType &e)
{
     DateNode *t;
     if ((q->rear==NULL)
     {
         return false;
     }
     t=q->front;
     if (q->front==q->rear)
     {    
         q->front=q->rear=NULL;
     }
     else
     {
          q->front=q->front->next;
         
     }
     e=t->data;
     free(t);
     return true;
 
}
int main()
{
	
}