循环队列和链式结构队列

一、循环队列的基础知识

1，循环队列有几个参数需要确定：

      有两个参数，front和rear

2，循环队列各个参数的含义

（1）队列初始化时，front和rear值都为零；

（2）当队列不为空时，front指向队列的第一个元素，rear指向队列最后一个元素的下一个位置；

（3）当队列为空时，front与rear的值相等，但不一定为零；

3.循环队列入队的伪算法

（1）把值存在rear所在的位置；

（2）rear=（rear+1）%maxsize ，其中maxsize代表数组的长度；

4.循环队列出队的伪算法

（1）先保存出队的值；

（2）front=（front+1）%maxsize ，其中maxsize代表数组的长度；

5.如何判断循环队列是否为空

if（front==rear）

队列空；

else

队列不空

6.如何判断循环队列是否为满

 这个问题比较复杂，假设数组的存数空间为7，此时已经存放1，a，5,7,22,90六个元素了，如果在往数组中添加一个元素，则rear=front；此时，队列满与队列空的判断条件front=rear相同，这样的话我们就不能判断队列到底是空还是满了；

解决这个问题有两个办法：一是增加一个参数，用来记录数组中当前元素的个数；第二个办法是，少用一个存储空间，也就是数组的最后一个存数空间不用，当（rear+1）%maxsiz=front时，队列满；

参考代码：

#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>
typedef struct Queue {
	int * PBase;//指向数组第一个元素的指针
	int front;//队列头部元素下标
	int rear;//队列尾部元素下标
}QUEUE;
/**
*初始化队列，实现队列的数组长度为6。
**/
void initQueue(QUEUE * pQ)
{
	pQ->PBase = malloc(sizeof(int) * 6);
	pQ->front = 0;
	pQ->rear = 0;
}
/**
判断队列是否已满
*/
bool isFull(QUEUE * pQ)
{
	if ((pQ->rear + 1) % 6 == pQ->front)
	{
		printf("队列已满，无法插入");
		return true;
	}

	return false;
}

/**
判断队列是否为空
*/

bool isEmpty(QUEUE * pQ)
{
	if (pQ->front == pQ->rear)
	{
		printf("队列为空");
		return true;
	}
	return false;
}
/**
入队
*/
bool insert(QUEUE * pQ, int val)
{
	if (isFull(pQ))
		return false;
	pQ->PBase[pQ->rear] = val;
	pQ->rear = (pQ->rear + 1) % 6;
	return true;
}

/**
遍历队列
*/

void traverse(QUEUE * pQ)
{
	int i = pQ->front;
	while (i != pQ->rear)
	{
		printf("%d  ", pQ->PBase[i]);
		i++;
	}
	printf("\n");
}

/**
出队
*/

bool  out_queue(QUEUE * pQ)
{
	if (isEmpty(pQ))
		return false;
	pQ->front = (pQ->front + 1) % 6;

}

int main()
{

	QUEUE Q;
	initQueue(&Q);
	insert(&Q, 1);
	insert(&Q, 2);
	insert(&Q, 3);
	insert(&Q, 4);
	insert(&Q, 5);
	insert(&Q, 6);
	traverse(&Q);
	out_queue(&Q);
	traverse(&Q);
	return 0;
}

二、链式队列

#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  
typedef int Item;
typedef struct node *PNode;
#define num 5  
typedef struct node
{
	Item data;
	PNode next;
}Node;

typedef struct queue *PQueue;

typedef struct queue
{
	PNode front;
	PNode rear;
	Item size;
}Queue;

/***创建空队列***/
PQueue Creat_Queue();

/***判断队列是否为空***/
int Is_Empty(PQueue);

PQueue CreateQueue(PQueue); //创建队列    


							/***数据项入队，在队尾入队***/
PQueue Add_Queue(PQueue, Item);

/***计算队列大小***/
int Size_Queue(PQueue);

/***数据项出队，在队首出队***/
Item Delete_Queue(PQueue);

/***清空队列***/
void Clear_Queue(PQueue);

/***遍历队列***/
void Traverse_Queue(PQueue);

/***创建空队列***/
PQueue Creat_Queue()
{
	PQueue P = (PQueue)malloc(sizeof(Queue));
	P->rear = P->front = (PNode)malloc(sizeof(Node));
	if (NULL == P || NULL == P->front)
	{
		printf("The queue is failed.\n");
		exit(1);
	}
	//P->front=P->rear;  
	P->front->next = NULL;
	P->size = 0;
	return P;
}

/***判断队列是否为空***/
int Is_Empty(PQueue P)
{
	if (P->front == P->rear)
		return 1;
	else
		return 0;
}

PQueue CreateQueue(PQueue P) //创建队列    
{
	P = Creat_Queue();
	printf("Enter the data:");
	int k;
	while ((scanf_s("%d", &k)) == 1)
	{
		Add_Queue(P, k);
		printf("Enter the next data:");
	}
	return P;
}

/***数据项入队,在队尾入队***/
PQueue Add_Queue(PQueue P, Item data)
{
	PNode temp = (PNode)malloc(sizeof(Node));
	if (NULL == temp)
	{
		printf("The temp is failed.\n");
		exit(1);
	}
	temp->data = data;
	temp->next = NULL;
	if (Is_Empty(P))
		P->front->next = temp;
	else
		P->rear->next = temp;
	P->rear = temp;
	P->size++;
	printf("Add the data of %d to queue is success: %d\n ", data, data);
	return P;
}

/***计算队列大小***/
int Size_Queue(PQueue P)
{
	return P->size;
}

/***数据项出队，在队首出队***/
Item Delete_Queue(PQueue P)
{
	Item data;
	if (Is_Empty(P))
		return NULL;
	PNode temp = P->front->next;
	data = temp->data;
	P->front->next = temp->next;
	if (0 == P->size)
		P->rear = P->front;
	P->size--;
	free(temp);
	return data;
}

/***清空队列***/
void Clear_Queue(PQueue P)
{
	PNode temp = P->front->next;
	while (temp)
	{
		PNode tp = temp;
		temp = temp->next;
		free(tp);
	}
	temp = P->front;
	P->front = P->rear = NULL;
	free(temp);
}

/***遍历队列***/
void Traverse_Queue(PQueue P)
{
	if (Is_Empty(P))
		printf("there is no data in the queue!\n");
	else
	{
		PNode pCurrent = P->front->next;
		printf("Now datas int the queue are:\n");
		while (pCurrent)
		{
			printf("%d ", pCurrent->data);
			pCurrent = pCurrent->next;
		}
		printf("\n");
	}
	return;
}

int main()
{

	/***创建空队列***/
	PQueue PQ;
	int size = 0;
	int data;
	PQ = Creat_Queue();
	printf("The queue is created.\n");

	/***判断队列是否为空***/
	if (Is_Empty(PQ))
		printf("The queue is empty.\n");

	PQ = CreateQueue(PQ); //创建队列  
						  /***遍历队列***/
	Traverse_Queue(PQ);

	/***数据项入队，在队尾入队***/
	PQ = Add_Queue(PQ, num);
	/***遍历队列***/
	Traverse_Queue(PQ);

	/***计算队列大小***/
	size = Size_Queue(PQ);
	printf("The size of queue are: %d\n", size);

	/***数据项出队，在队首出队***/
	data = Delete_Queue(PQ);
	printf("The deleted data is: %d\n", data);
	/***遍历队列***/
	Traverse_Queue(PQ);

	/***清空队列***/
	Clear_Queue(PQ);
	if (Is_Empty(PQ))
		printf("The queue is empty.\n");
	/***遍历队列***/
	Traverse_Queue(PQ);

	return 0;
}