数据结构学习笔记——队列

队列的定义

队列的顺序存储结构和基本运算的实现

类型声明

初始化队列

销毁队列

判断队列是否为空

进队列

出队列

环形队列

基本运算

初始化

销毁

判断队列是否为空

进队列

出队列

链队

链队的基本运算

初始化

销毁

判断是否为空

进队列

出队列

不带头结点只有一个尾节点指针的循环单链表存储队列

基本运算

初始化

进队

出队

判断是否为空

对列的定义：
一种操作受限制的线性表，仅允许在表的一端进行插入操作，在另一端进行删除操作，把进行插入操作的一端叫做队尾，进行删除操作的叫做队首。删除元素叫做出队，插进元素叫做入队。

队列的顺序存储结构以及基本运算的实现：
采用顺序表的存储结构，并用两个整形变量来反映队列中元素的变化，它们分别存储队首元素和对尾元素的下标位置，分别称作队首指针和队尾指针。采用顺序存储结构的队列称作顺序队。

基本运算：
类型声明：

#define maxsize 100
typedef int Elemtype;
typedef struct
{
	Elemtype data[maxsize];
	int front,rear;
} SqQueue;

初始化队列：

SqQueue* InitQueue(SqQueue *q)
{
	q = (SqQueue *)malloc(sizeof(SqQueue));
	q -> front = q -> rear = -1;
	return q;
}

销毁队列：
直接释放指向队列那个指针所指向的存储空间即可。

void DestroyQueue(SqQueue *q)
{
	free(q);
}

判断队列是否为空：
只要看队首元素是否和队尾元素相等。

_Bool QueueEmpty(SqQueue *q)
{
	return (q -> front == q -> rear);
}

进队列：
在队列不满的情况下将尾指针增1，然后将元素e插入到该位置。

_Bool enQueue(SqQueue *q,Elemtype e)
{
	if (q -> rear == maxsize -1) return 0;
	else
	{
		q -> rear ++;
		q -> data[q -> rear] = e;
		return 1;
	}
}

出队列：
在队列不为空的情况下队首指针增1，然后将该位置的元素赋给e。

_Bool deQueue(SqQueue *q,Elemtype e)
{
	if (q -> front == q -> rear) return 0;
	else
	{
		q -> front ++;
		e = q -> data[q -> front];
		return 1;
	}
}

环形队列：
在逻辑上将队首与队尾结合起来。
为了实现从队首到队尾的过渡，指针循环增1的算法应采用取余算法：

front = (front +1)%maxsize;
rear = (rear +1)%maxsize;

环形队列的队首和队尾指针开始都设置为0.
队空的条件：队首指针等于队尾指针。
队满的条件：如果把整个数组全都装满元素定义为队满，那么队满时两个指针也会相等，这就无法和队空相区分，所以我们就把队满定义为队尾指针加一再对maxsize取余数，所得若等于队首指针，那么就队满。也就是队尾指针所指的元素紧挨着队首元素所指向的空间，但是队首元素那里不放置元素。
基本运算：
初始化队列：

void InitQueue(SqQueue *p)
{
	p = (SqQueue *)malloc(sizeof(SqQueue));
	p -> front = p -> rear = 0;
}

销毁队列：

void DestroyQueue(SqQueue *p)
{
	free(p);
}

判断队列是否为空：

_Bool QueueEmpty(SqQueue *p)
{
	return (p -> front == p -> rear);
}

进队列：

_Bool enQueue(SqQueue *q,Elemtype e)
{
	if ((q -> rear + 1)%maxsize == q -> front) return 0;
	else
	{
		q -> rear = (q -> rear +1)%maxsize;
		q -> data[q -> rear] = e;
		return 1;
	}
}

出队列：

_Bool deQueue(SqQueue *q,Elemtype *e)
{
	if (q -> front == q -> rear) return 0;
	else
	{
		q -> front ++;
		*e = q -> data[q -> front];
		return 1;
	}
}

链队：
采用链表存储结构的队列。

基本运算：
链队数据结点的类型声明：
数据结点：数据域+指针域

typedef struct qnode
{
	Elemtype data;
	struct qnode *next;
} DataNode;

链队结点：队首指针+队尾指针

typedef struct
{
	DataNode *front;
	DataNode *rear;
} LinkQuNode;

初始化队列：
就是创造一个空队，也就是front和rear均为NULL的链队结点。

void InitLinkQueue(LinkQuNode *p)
{
	p = (LinkQuNode *)malloc(sizeof(LinkQuNode));
	p -> front = NULL;
	p -> rear = NULL;
}

销毁队列：
销毁链队结点和数据结点。

void DestroyLinkQueue(LinkQuNode *q)
{
	DataNode *pre = p -> front;
	DataNode *p = pre -> next;
	if (pre != NULL)
	{
		while(p!= NULL)
		{
			free(pre);
			pre = p;
			p = p -> next;
		}
		free(pre);
	}
	free(q);
}

判断队列是否为空：
判断指针之一是否指向元素即可。

_Bool LinkQuEmpty(LinkQuNode *p)
{
	return (p -> front == NULL);
}

进队列：
创建数据结点，赋值，在rear后面插入，让rear指向这个结点。

void enLinkQueue(LinkQuNode *p,Elemtype e)
{
	DataNode *s;
	s = (DataNode *)malloc(sizeof(DataNode));
	s -> data = e;
	s -> next = NULL;
	if (p -> rear == NULL) p -> front = p -> rear = s;
	else
	{
		p -> rear -> next = s;
		p -> rear = s;
	}
}

出队列：
若是空队列，返回错误；只有一个结点，标记结点，设置双指针为NULL；否，则取值，标记，移位，释放。

_Bool deLinkQueue(LinkQuNode *p,Elemtype *e)
{
	DataNode *t;
	if (p -> front == NULL) return 0;
	else if(p -> front == p -> rear)
	{
		*e = p -> front -> data;
		t = p -> front;
		p -> front = p -> rear = NULL;
		free(t);
		return 1;
	}
	else
	{
		*e = p -> front -> data;
		t = p -> front;
		p -> front = t -> next;
		free(t);
		return 1;
	}
}

只有尾结点的循环单链表：
与链队相比，此种队列少了队首指针，或者是说队首指针在队尾结点的指针域里面。

基本运算：
初始化：
一个空指针。

typedef int Elemtype;
typdef struct Node
{
	Elemtype data;
	struct Node *next;
} LinNode;

void InitQueue(LinkNode *p)
{
	p = NULL;
}

进队：
若队列为空，则将结点变成循环链表后将rear指向这个结点；否则先让这个结点指向队首元素，然后变成队尾元素，最后将rear指向这个结点。两种情况就是把链表重新变成循环链表的方法不一样，其他的都一样，所以可以将这两种情况融合。

void enQueue(LinkNode *p,Elemtype e)
{
	LinkNode *s;
	s = (LinkNode *)malloc(sizeof(LinkNode));
	s -> data = e;
	s -> next = NULL;
	if (p == NULL) s -> next = s;
	else
	{
		s -> next = rear -> next;
		rear -> next = s;
	}
	rear = s;
}

出队：

_Bool enQueue(LinkNode *p,Elemtype *e)
{
	if (p == NULL) return 0;
	else if(p -> next == p)
	{
		free(p);
		p = NULL;
	}
	else
	{
		LinkNode *t;
		t = p -> next;
		*e = t -> data;
		p -> next = t -> next;
		free(t);
	}
	return 1;
}

判断是否为空：

_Bool QueueEmpty(LinkNode *p)
{
	return(p == NULL);
}