队列的定义和基本操作的实现

写代码：定义顺序存储的队列（数组实现），要求数组空间可以被循环利用 
写代码：基于上述定义，实现“出队、入队、判空、判满”四个基本操作 
写代码：定义链式存储的队列（单链表实现） 
写代码：基于上述定义，实现“出队、入队、判空、判满”四个基本操作 

1.定义顺序存储的队列（数组实现），要求数组空间可以被循环利用  

2.出队、入队、判空、判满

#include <stdio.h>

#define MaxSize 50

typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];//用于存储元素的数组 
	int front;//指向队列前端的指针 
	int rear;//指向队列后端的指针 
	
}sqQueue;

//初始化
void initQueue(sqQueue &q)
{
	q.rear=q.front=0;
} 
//判空
bool isEmpty(sqQueue q)
{
	if(q.rear==q.front){
		//TODO
		return true;
	}else{
		return false;
	}
} 
//判满
bool fullQueue(sqQueue &q)
{
	if((q.rear+1)%MaxSize==q.front){
		//TODO
		return true;
	}else{
		return false;
	}
}
//入队
bool enQueue(sqQueue &q,ElemType e)
{
	if((q.rear+1)%MaxSize==q.front){
		
		//TODO
		return false;
	}
	q.data[q.rear]=e;
	q.rear=(q.rear+1)%MaxSize;
	return true; 
} 
//出队
bool deQueue(sqQueue &q,ElemType e)
{
	if(q.rear==q.front){
		//TODO
		return false;
	}
	e=q.data[q.front];
	q.front=(q.front+1)%MaxSize;
	return true;
	
} 

3.定义链式存储的队列（单链表实现） 

4.基于上述定义，实现“出队、入队、判空、判满”四个基本操作  

 链式队列不存在队列已满的情况。在内存足够大的情况下,每次动态申请链表结点内存都会成功,即不会出现队列已满的情况,除非数据量超大内存不够。

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

typedef int ElemType;

typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
}LinkNode;

typedef struct{//链式队列 
	LinkNode *front,*rear;//队列的队头和队尾指针 
}LinkQueue;

//初始化
void initQueue(LinkQueue &q)//初始化带头结点的链队列 
{
	q.front=q.rear=(LinkNode*)malloc(sizeof(LinkNode));//建立头结点
	q.front->next=NULL;	//初始化为空 
	
} 
//判空
bool isEmpty(LinkQueue q)
{
	if(q.front==q.rear){
		//TODO
		return true;
	}else{
		return false;
	}
} 
//入队
void enQueue(LinkQueue &q,ElemType e)
{
	LinkNode *s=(LinkNode*)malloc(sizeof (LinkNode));//创建新结点
	s->data=e;
	s->next=NULL;
	q.rear->next=s;//插入链尾
	q.rear=s;//修改尾指针 
} 
//出队
bool deQueue(LinkQueue &q ,ElemType e)
{
	if(q.front==q.rear){
		//TODO
		return false;//空队
		 
	}
	LinkNode *p=q.front->next;
	e=p->data;
	q.front->next=p->next;
	if(q.rear==p){
		//TODO
		q.rear=q.front;
	}
	free(p);
	return true;
}