队列的链式结构

队列的链式结构

队列的链式存储结构，其实就是线性表的单链表，只是只能够尾进头出而已。为了操作的方便，我们将队头指针指向链队列的头结点，队尾指针指向终点结点，如下图所示。

空队列是，front和rear同时指向头结点。链式队列基本没有满队列。

链式队列的类型定义：

<span style="font-size:14px;">typedef struct QNode
{
	Datatype data;
	struct QNode *next;
}LQNode, *QueuePtr;
//链式队列的定义
typedef struct
{
	QueuePtr front, rear;
}LinkQueue;</span>

二：链式队列的实现

LinkQueue.c文件

#include "LinkQueue.h"
#include <stdio.h>

//初始化链式队列
void InitQueue(LinkQueue *LQ)
{
	LQ->front = LQ->rear = (LQNode *)malloc(sizeof(LQNode));		//创建头结点= 尾结点
	if(LQ->front == NULL)			//创建失败
		exit(-1);	
	LQ->front->next = NULL;			//把头结点的指针域设为NULL
}

//判断链式队列是够为空
int QueueEmpty(LinkQueue LQ)
{
	if(LQ.front->next == NULL)		//判断头结点的指针域是否NULL
		return 1;
	else 
		return 0;
}

//入队操作
int EnterQueue(LinkQueue *LQ, DataType e)
{
	LQNode *s;
	s = (LQNode *)malloc(sizeof(LQNode));		//为入队的元素申请一个结点
	if(!s)
		exit(-1);
	s->data = e;								//将元素值赋值给结点的数据域
	s->next = NULL;								//将结点的指针域为NULL
	LQ->rear->next = s;							//将原来队列的队尾指针指向s
	LQ->rear = s;								//将尾指针指向s
	return 1;
}

//出队操作
int DeleteQueue(LinkQueue *LQ,DataType *e)
{
	LQNode *p;
	if(LQ->front == LQ->rear)			//判断队列为空
		return 0;
	else 
		p = LQ->front->next;
		*e = p->data;		//*e为将要删除的数值
		LQ->front->next = p->next;			//将对原结点的next指向后一个结点
		if(LQ->rear == p)					//如果队头是队尾
			LQ->rear = LQ->front;
		free(p);
		return 1;
}

//取队头元素
int GetHead(LinkQueue LQ,DataType *e)
{
	if(LQ.front == LQ.rear)		//判断是否为空队列
		return 0;
	else
		*e = LQ.front->next->data;		//取队头元素
		return 1;
}

//求队长操作
int QueueLength(LinkQueue LQ)
{
	LQNode *p;
	int count = 0;
	p = LQ.front;					//p指向栈顶指针
	while(p->next != NULL)		//判断栈是否还有结点<pre name="code" class="cpp">}

LinkQueue.h文件

#ifndef _LINKQUEUE_H
#define _LINKQUEUE_H

typedef char DataType;

//链式队列结点定义
typedef struct QNode
{
	DataType data;
	struct QNode *next;
}LQNode,*QueuePtr;

//定义队列类型
typedef struct 
{
	QueuePtr front,rear;
}LinkQueue;

//初始化链式队列
void InitQueue(LinkQueue *LQ);
//判断链式队列是够为空
int QueueEmpty(LinkQueue LQ);
//入队操作
int EnterQueue(LinkQueue *LQ, DataType e);
//出队操作
int DeleteQueue(LinkQueue *LQ,DataType *e);
//取队头元素
int GetHead(LinkQueue LQ,DataType *e);
//求队长操作
int QueueLength(LinkQueue LQ);
//清空队列
void ClearQueue(LinkQueue *LQ);


#endif

3:main.c文件

<strong>/*判断字符序列事是否为回文，采用队列和栈的方法，队列是先进先出，栈是先进后出
若出队的和出栈的元素一致，则是回文*/

#include <stdio.h>
#include "LinkQueue.h"
#include "LinkStack.h"

void main()
{
	LinkQueue LQueue1,LQueue2;			//定义链式队列
	LStackNode *LStack1,*LStack2;			//定义链式栈
	char str1[] = "XYZAZYX";			//需要判断的字符串
	char str2[] = "XYHJHAA";
	char q1,s1,q2,s2;
	int i;

	InitQueue(&LQueue1);				//初始化链式队列和栈
	InitQueue(&LQueue2);
	InitStack(&LStack1);
	InitStack(&LStack2);
	
	for(i = 0; i<strlen(str1); i++)		
	{
		EnterQueue(&LQueue1,str1[i]);		//依次将字符序列1入队
		EnterQueue(&LQueue2,str2[i]);		//依次将字符序列2入队
		PushStack(LStack1,str1[i]);		//依次将字符序列1进栈
		PushStack(LStack2,str2[i]);		//依次将字符序列2进栈	
	}

	printf("字符序列1：\n");
	printf("出队序列     出栈序列\n");

	while(!StackEmpty(LStack1))				//判断字符序列是否全出栈
	{
		DeleteQueue(&LQueue1,&q1);			//队列出队
		PopStack(LStack1,&s1);				//出栈
		printf("%5c",q1);
		printf("%10c\n",s1);
		if(q1 != s1)						//比较出列的元素是否和出栈的元素一值
		{
			printf("字符序列1不是回文：\n");
			break;
		}
		if(StackEmpty(LStack1))				//判断字符序列是否全出栈
			printf("字符序列1是回文：\n");
	}

	printf("字符序列2：\n");

	printf("出队序列     出栈序列\n");
	while(!StackEmpty(LStack2))				//判断字符序列是否全出栈
	{
		DeleteQueue(&LQueue2,&q2);
		PopStack(LStack2,&s2);
		printf("%5c",q2);
		printf("%10c\n",s2);
		if(q2 != s2)						//比较出列的元素是否和出栈的元素一值
		{
			printf("字符序列2不是回文：\n");
			break;
		}
		if(StackEmpty(LStack2))
			printf("字符序列2是回文：\n");
	}

}</strong>

结果显示：