数据结构——链队列与循环队列

一.链队列

1.定义

//链队列节点
typedef struct LinkNode
{
	int data;
	struct LinkNode* next;
}*LinkNodePtr;
 
//链队列 
typedef struct LinkQueue
{
	LinkNodePtr front;
	LinkNodePtr rear;
 } *LinkQueuePtr;

2.初始化

//初始化
LinkQueuePtr initQueue() 
{
	LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));
	LinkNodePtr headPtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	headPtr->data = -1;
	headPtr->next = NULL;
	resultPtr->front = headPtr;
	resultPtr->rear = headPtr;
	return resultPtr;
 }
3.打印
//打印
void outputQueue(LinkQueuePtr paraQueuePtr)
{
	LinkNodePtr tempPtr = paraQueuePtr->front->next;
	while(tempPtr != NULL)
	{
		printf("%d ",tempPtr->data);
		tempPtr = tempPtr->next;
	}
	printf("\n");
 }

3.入队

void enterQueue(LinkQueuePtr paraQueuePtr,int paraElem)
{
	LinkNodePtr tempPtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	tempPtr->data = paraElem;
	tempPtr->next = NULL;
	
	paraQueuePtr->rear->next = tempPtr;
	paraQueuePtr->rear = tempPtr;	
 } 

4.出队

int deleteQueue(LinkQueuePtr paraQueuePtr)
{
	int result;
	LinkNodePtr tempPtr;
	//判断队列是否为空
	if(paraQueuePtr->front == paraQueuePtr->rear)
	{
		printf("队列为空，不能删除\n");
		return -1;
	 } 
	tempPtr = paraQueuePtr->front->next;
	result = tempPtr->data;
	paraQueuePtr->front->next = tempPtr->next;
	if(paraQueuePtr->rear == tempPtr)
	{
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	free(tempPtr);
	return result;
 }

测试结果

5 10 15 20
删除5
删除10
15 20
删除15
删除20
队列为空，不能删除
删除-1
13

二.循环队列

1.定义

//循环队列
typedef struct CircleQueue
{
	int data[TOTAL_SPACE];
	int head;//队首 
	int tail;//队尾 
 } *CircleQueuePtr;

2.初始化

//初始化
CircleQueuePtr initCircleQueue()
{
   CircleQueuePtr resultPtr = (CircleQueuePtr)malloc(sizeof(struct CircleQueue));
   resultPtr->head = 0;
   resultPtr->tail = 0;
   return resultPtr;
}

3.打印

//打印
void outputQueue(CircleQueuePtr paraPtr)
{
	int i;
	if(paraPtr->head == paraPtr->tail)
	{
		printf("队列为空.\n");
		return;
	}
	printf("队列:");
	for(i = paraPtr->head;i < paraPtr->tail;i++)
	{
		printf("%d ",paraPtr->data[i % TOTAL_SPACE]);
	}
	printf("\n");
 } 

4.入队

//入队
void enterQueue(CircleQueuePtr paraPtr,int paraData)
{
	if((paraPtr->tail+1) % TOTAL_SPACE == paraPtr->head)
	{
		printf("队列已满.\n");
		return;
	}
	paraPtr->data[paraPtr->tail%TOTAL_SPACE] = paraData;
	paraPtr->tail++;
 } 

5.出队

//出队 
int deleteQueue(CircleQueuePtr paraPtr)
{
	int result;
	if(paraPtr->head == paraPtr->tail)
	{
		printf("队列为空，不能删除.\n");
		return -1;
	}
	result = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
	return result;
 } 

测试结果

队列已满.
队列:9 10 11 12 13
删除9
删除10
删除11
删除12
队列:13
删除13
队列为空，不能删除.
删除-1
队列为空，不能删除.
删除-1

队列和之前的栈主要区别在于

（1）操作的名称不同。队列的插入称为入队，队列的删除称为出队。栈的插入称为进栈，栈的删除称为出栈。

（2）可操作的方式不同。队列是在队尾入队，队头出队，即两边都可操作。而栈的进栈和出栈都是在栈顶进行的，无法对栈底直接进行操作。

（3）操作的方法不同。队列是先进先出（FIFO），即队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（不能从中间插入），每次离开的成员总是队列头上（不允许中途离队）。而栈为后进先出（LIFO）,即每次删除（出栈）的总是当前栈中最新的元素，即最后插入（进栈）的元素，而最先插入的被放在栈的底部，要到最后才能删除。