【数据结构】链式队列

//linkqueue.h
#include "stdio.h"
#include "stdlib.h"
#include <string.h>
#define MAXSZIE 30

struct qNode
{	char name[MAXSZIE];
char author[MAXSZIE];
int Pages;
double Price;
char IsForeign;
struct qNode * next;
};
typedef struct qNode QNode,*pNode;

typedef struct
{
	pNode front;
	pNode rear;
	int size;
}LinkQueue;

void InitQueue(LinkQueue *LQ);
//1.Init queue

int  QueueEmpty(LinkQueue LQ);
//1.if queue is  nut empty return 1;
//2.if queue is empty return 0;

int enqueue( LinkQueue *LQ,QNode item) ;
//1.Check that the queue and the item are not empty. Return -1 if they are.
//2.Create a new Record to save the data received from item. This Record will be added to the queue.
//3.Find the end of the queue. Be mindful that the queue may be empty.
//4.Return the value of a counter with the new size of the queue.

int dequeue(LinkQueue *LQ, QNode *item);
//1.Check if the queue is empty, if so the program will print “Nothing to dequeue!” and return -1.
//2.If the queue is not empty, copy the data of the front element into the Record item and remove the front element from the queue.
//3. free its memory. Return 1 when finished.

int GetHead(LinkQueue LQ,QNode item);
//1.If the queue is not empty,return the head item name;

void destroyQueue(LinkQueue * LQ) ;
//1.The method will dequeue and free the memory of all the elements in the queue.

void DislayQueue(LinkQueue LQ);
//1.printf all the elements in the queue.
//linkqueue.c
#include "QueueADT.h"

void InitQueue(LinkQueue *LQ)
{
	LQ->front=(pNode)malloc(sizeof(QNode));
	if(LQ->front==NULL) exit(-1);
	LQ->front->next=NULL;
	LQ->rear=LQ->front;
	LQ->size=0;
}

int QueueEmpty( LinkQueue LQ )
{
	if(LQ.rear->next==NULL)
		return 1;
	else
		return 0;
}

int enqueue( LinkQueue *LQ,QNode item )
{
	QNode *s=(QNode *)malloc(sizeof(QNode));
	if(!s) exit(-1);
	strcpy(s->author,item.author);
	s->IsForeign=item.IsForeign;
	strcpy(s->name,item.name);
	s->Pages=item.Pages;
	s->Price=item.Price;
	s->next=NULL;
	LQ->rear->next=s;
	LQ->rear=s;
	LQ->size++;
	return LQ->size;

}

int dequeue( LinkQueue *LQ, QNode *item )
{
	QNode *s;
	if(LQ->front==LQ->rear)
		return -1;
	else{
		s=LQ->front->next;
		strcpy(item->author,s->author);
		item->IsForeign=s->IsForeign;
		strcpy(item->name,s->name);
		item->Pages=s->Pages;
		item->Price=s->Price;
		LQ->front->next=s->next;
		if(LQ->rear==s)LQ->rear=LQ->front;
		free(s);
		return 1;
	}

}

int GetHead( LinkQueue LQ,QNode item )
{
	QNode *s;
	if(LQ.rear==LQ.front)
		return 0;
	else
	{
		s=LQ.front->next;
		strcpy(item.author,s->author);
		item.IsForeign=s->IsForeign;
		strcpy(item.name,s->name);
		item.Pages=s->Pages;
		item.Price=s->Price;
		return 1;

	}

}

void destroyQueue( LinkQueue * LQ )
{		QNode *s;

	if(LQ->front!=LQ->rear)
	{
		s=LQ->front->next;
		LQ->front->next=s->next;
		if(LQ->rear==s)LQ->rear=LQ->front;
		free(s);
		destroyQueue(LQ);
	}else
	{
		LQ->rear->next=LQ->front;
	}
}

void DislayQueue( LinkQueue LQ )
{
	QNode * p;
	int i=1;
	printf("  ID                          NAME              AUTHOR         PAGES    PRICE      ISFOREIGN\n");
	p=LQ.front->next;
	while(p&&QueueEmpty(LQ)==1)
	{
	printf("[%2d]:%30s %25s%5d %10.2f %10c\n", i, p->name,p->author ,p->Pages, p->Price,p->IsForeign);
	i++;
	p=p->next;
	}
	printf("\nSIZE = %d\n",i-1);
	printf("************************************************************************************************\n");

}

main.c

//gt Final Grade 100/100

//gt Program compiles and runs

#include "QueueADT.h"

/*
author:zhaoke
date:2014.12.4
project:QueueADT.
*/

void main()
{	int i=0;
	QNode p;
	LinkQueue LQ;
///////////////////////////////////////////////////////////////////////
	InitQueue(&LQ);
//	add item to Qrere
	strcpy(p.name,"Romance of the Three Kingdoms");
	strcpy(p.author,"LuoGuanZhong");
	p.Price=50.5;
	p.Pages=365;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name,"Water Margin");
	strcpy(p.author,"ShiNaiAn");
	p.Price=80.5;
	p.Pages=465;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name,"A Dream of Red Mansions");
	strcpy(p.author,"CaoXueQin");
	p.Price=46.5;
	p.Pages=532;
	p.IsForeign='N';
	enqueue(&LQ,p);;

	strcpy(p.name,"Jane Eyre");
	strcpy(p.author,"Charlotte Bronte");
	p.Price=66.5;
	p.Pages=432;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"the making of steel");
	strcpy(p.author,"Pavel Korchagin");
	p.Price=85.5;
	p.Pages=432;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"Robinson Crusoe");
	strcpy(p.author,"Daniel Defoe");
	p.Price=85.5;
	p.Pages=672;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"The Merchant of Venice");
	strcpy(p.author,"WilliamShakesbeare");
	p.Price=95.5;
	p.Pages=572;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"The Tragedy of Hamlet");
	strcpy(p.author,"WilliamShakesbeare");
	p.Price=95.5;
	p.Pages=1072;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"Othello");
	strcpy(p.author,"WilliamShakesbeare");
	p.Price=95.5;
	p.Pages=882;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"The life of King Henry Ⅷ");
	strcpy(p.author,"WilliamShakesbeare");
	p.Price=105.5;
	p.Pages=682;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name," Les Misrables  ");
	strcpy(p.author,"Victor Hugo");
	p.Price=85.5;
	p.Pages=452;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"Notre-Dame de Paris");
	strcpy(p.author,"Victor Hugo");
	p.Price=85.5;
	p.Pages=752;
	p.IsForeign='Y';
	enqueue(&LQ,p);

	strcpy(p.name,"Red Sorghum");
	strcpy(p.author,"MoYan");
	p.Price=85.5;
	p.Pages=642;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name,"Wa");
	strcpy(p.author,"MoYan");
	p.Price=23.5;
	p.Pages=452;
	p.IsForeign='N';
	enqueue(&LQ,p);;

	strcpy(p.name,"Sadness into river upstream");
	strcpy(p.author,"Jing M.Guo");
	p.Price=52.5;
	p.Pages=552;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name,"Tiny Times");
	strcpy(p.author,"Jing M.Guo");
	p.Price=58.5;
	p.Pages=512;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name," Let the wind cutting dusts");
	strcpy(p.author,"Jing M.Guo");
	p.Price=28.5;
	p.Pages=532;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name,"Triple gate");
	strcpy(p.author,"HanHan");
	p.Price=58.5;
	p.Pages=132;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name,"Ordinary world");
	strcpy(p.author,"LuYao");
	p.Price=16.5;
	p.Pages=1324;
	p.IsForeign='N';
	enqueue(&LQ,p);

	strcpy(p.name,"If you well is sunny");
	strcpy(p.author,"BaiLuoMei");
	p.Price=58.5;
	p.Pages=263;
	p.IsForeign='N';
	enqueue(&LQ,p);
////////////////////////////////////////////////////////////////////
	printf("Creating data and pushing it to the Queue:\n");
	DislayQueue(LQ);

////////////////////////////////////////////////////////////////////
	strcpy(p.name,"DateStruct");
	strcpy(p.author,"YanWeiMin");
	p.Price=60.3;
	p.Pages=280;
	p.IsForeign='N';
	enqueue(&LQ,p);
	printf("Pushing new value on Queue:\n");
	DislayQueue(LQ);
////////////////////////////////////////////////////////////////////
	printf("Delete 5 elements from the Queue:\n\n");
	for(i=0;i<5;i++)
	{
		dequeue(&LQ, &p );
		printf("ElementName[%d]:%s\n",i+1,p.name);
	}
	DislayQueue(LQ);
//////////////////////////////////////////////////////////////////
	if(QueueEmpty(LQ)!=1)
	{
		printf("Queue is empty\n");
	}
	else
	{
		printf("Queue is NOT empty\n");
	}
	DislayQueue(LQ);
//////////////////////////////////////////////////////////////////
	printf("Destroying the Queue\n");
	destroyQueue(&LQ);
	if(QueueEmpty(LQ)!=1)
	{
		printf("Queue is empty\n");
	}
	else
	{
		printf("Queue is NOT empty\n");
	}

	DislayQueue(LQ);

}
时间: 2024-10-28 21:22:15

【数据结构】链式队列的相关文章

数据结构Java实现07----队列:顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

数据结构之---C语言实现链式队列

//链式队列的存储 //杨鑫 #include <stdio.h> #include <stdlib.h> typedef int QElemType; //定义节点 typedef struct QNode { QElemType data; struct QNode *next; }QNode, *QueuePtr; //定义指针 typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; //插入元素e进入队列 vo

【数据结构-队列】链式队列

关于链式队列 链式队列又称为链队,是使用单链表实现的,需要一个头指针一个尾指针 结构图: 链队需要的元素组成 /*链式队列的每一个节点*/ struct node{ int data;//存储数据 struct node *next;//指向下一个节点的指针 }; /*链式队列*/ typedef struct{ struct node *head;//头指针 struct node *tail;//尾指针 }LinkedQueue; 创建一个带头节点的空队列 创建一个节点p 将p节点的next

数据结构基础(14) --链式队列的设计与实现

链式队列是基于单链表的一种存储表示, 其形状如下图所示: (队列的队头指针指向单链表的第一个结点, 队尾指针指向单链表的最后一个结点, 注意没有无用的空[头/尾]节点) 用单链表表示的链式队列特别适合于数据元素变动比较大的情况, 而且不存在队列满而产生溢出的情况; 链式队列结点构造: [这次我们将节点构造成了类LinkQueue的嵌套类] struct ChainNode { ChainNode(const Type &_data, ChainNode *_next = NULL) :data(

链式队列的实现

链式队列数据结构如下: typedef struct qnode{ ElemType data; struct qnode* next; //指向下一节点指针 }QNode; typedef struct{ QNode* front; //队首指针 QNode* rear; //队尾指针 }ListQueue; 实现以下函数: void InitQueue(ListQueue* &q); //初始化队列 void ClearQueue(ListQueue* &q); //清空队列 int

顺序队列和链式队列的实现

队列是一种常用的数据结构,它跟栈一样,操作都受到限制,队列只允许从一端进数据,另一端出数据.队列跟栈不同,栈是一种"后进先出"的模式,而队列是一种"先进先出"的操作模式.就好比日常排队一样,先排队的先出,后排队的后出.例如,进入队列的顺序是1,2,3,4,5则出队列的顺序是1,2,3,4,5(只考虑一次性出列的情况). 队列也分顺序队列和链式队列,跟顺序栈和链表栈一样,顺序队列同样是基于数组实现,链式队列则是基于链表实现. 顺序队列: //顺序队列 #include

链式队列总结

基本数据结构之-链式队列 链式队列就是一个操作受到限制的单链表,学会了单链表再来写这个就是轻松加愉快,但是貌似我去用了两个小时搞定,主要是基础差! 队列的基本操作就是入栈和出栈,还可以看到对头和对尾 如果维护了长度参数,那么也可以返回一个长度 不说理论了,直接上代码吧! 首先定义基本数据结构的结构体: typedef struct _LINKQUEUENODE { struct _LINKQUEUENODE *next; }LinkQueueNode; typedef struct _LINKQ

链式队列(Linked Queue)

链式队列(Linked Queue) 1. 链式队列的概念 1.1 链式队列的定义 链式队列是基于链表的存储表示实现的队列. 1.2 链式队列中各元素的逻辑及存储关系 链式队列可以采用单链表作为其存储表示,因此,可以在链式队列的声明中用单链表定义它的存储空间. 链式队列的队头指针指向单链表的第一个结点,队尾指针指向单链表的最后一个结点. 注:链式队列的队头元素存放在单链表的第一个结点内,若要从队列中退出一个元素,必须从单链表中删去第一个结点,而存放着新元素的结点应插在队列的队尾,即单链表的最后一

链式队列的C++实现

链式队列的C++实现 一.数据结构 struct QNode //定义队列结点的数据结构 { QNode *next; //指针域,指向下一个结点 double data; //数据域,存储队列信息 }; struct LinkQueue //定义队列的数据结构 { QNode *front; //队首指针,指向QNode类型的指针 QNode *rear; //队尾指针 }; void InitQueue(LinkQueue &Q) //构造一个空的队列 int IsEmpty(LinkQue

链式队列基本操作的实现问题

问题描述:用链式存储方式实现队列的基本操作 涉及变量:front:Node型自定义变量,指向队首元素 rear:Node型自定义变量,指向队尾元素 涉及教材:<数据结构--Java语言描述(第2版)> 清华大学出版社 大致思路: 链式存储结构不害怕出队列会浪费空间,因此也不需要要循环结构来节约空间 front为指向队首结点的指针 rear为指向队尾结点的指针 初始化时它们均指向空 初始化代码如下: 队列的置空方法与初始化相类似 而判断队列是否为空只需要判断队首指针是否指向非空元素即可 代码如下