数据结构3.6链队列，3.7循环队列

3.6链队列

转载：链队列与链表相似，不同的是它具有对列的运算方法，存储结构和链表相同，下面是其结构示意图：

 这里的*Q类似于链表的头节点*head；它包含两个指向队列节点的指针front和rear；当front和rear都为ＮＵＬＬ时队列为空；front指向队列第一个节点，rear指向最后一个节点，当两者指向同一个节点说明队列只有一个节点；
还有不设头指针的链队列表示形式，这里不予说明；
代码部分：

#include
#include

typedef struct LinkNode {
	int data;
	LinkNode* next;
}*LinkNodePtr;


typedef struct LinkQueue {
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;


LinkQueuePtr initQueue()
{
	LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));
	//The header ,the data is not useful
	LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	headerPtr->next = NULL;
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	return resultPtr;
	
}

void outputLinkQueue(LinkQueuePtr paraQueuePtr) {
	LinkNodePtr tempPtr = paraQueuePtr->front->next;
	while (tempPtr != NULL)
	{
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	printf("rn");
}

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement)
{
	//step 1.create a new node
	LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	//step 2.Link to the existing rear
	paraQueuePtr->rear->next = tempNodePtr;
	//step 3.
	paraQueuePtr->rear = tempNodePtr;
}

int dequeue(LinkQueuePtr paraQueuePtr)
{
	int resultValue;
	LinkNodePtr tempNodePtr;
	//step 1.检测是否链表为空
	if (paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is emptyrn");
		return -1;
	}
	//step 2.Change the queue
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;
	if (paraQueuePtr->rear == tempNodePtr) {
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	//step 3.Free space
	tempNodePtr = NULL;
	//Step 4.Return 
	return resultValue;
	}

void testLinkQueue() {
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 10);
	enqueue(tempQueuePtr, 30);
	enqueue(tempQueuePtr, 50);

	outputLinkQueue(tempQueuePtr);

	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));
	printf("dequeue gets %drn", dequeue(tempQueuePtr));

	enqueue(tempQueuePtr, 8);
	outputLinkQueue(tempQueuePtr);
}
int main() {
	testLinkQueue();
	return 1;
}

运行结果：

10 30 50
dequeue gets 10
dequeue gets 30
dequeue gets 50
The queue is empty
dequeue gets -1
8

3.7循环队列

百度百科：为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。

为了区分空队列与满队列, 需要留一个空间. 相当于不允许首尾相连.

网图：

#include 
#include 

#define TOTAL_SPACE 5

typedef struct CircleIntQueue {
	int data[TOTAL_SPACE];
	int head;
	int tail;
}*CircleIntQueuePtr;

CircleIntQueuePtr initQueue() {
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;

	return resultPtr;
}

void enqueue(CircleIntQueuePtr paraPtr, int paraValue)
{
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head)
	{
		printf("Queue fullrn");
		return;
	}
	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail++;
}

int dequeue(CircleIntQueuePtr paraPtr)
{
	int resultValue;
	if (paraPtr->head == paraPtr->tail)
	{
		printf("No element in the queuern");
		return -1;
	}
	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
	return resultValue;
}
void outputLinkQueue(CircleIntQueuePtr paraPtr) {
	int i;
	if (paraPtr->head == paraPtr->tail)
	{
		printf("Empty queue");
		return;
	}
	printf("Elements in the queue ");
	for (i = paraPtr->head; i < paraPtr->tail; i++)
	{
		printf("%d, ", paraPtr->data[i % TOTAL_SPACE]);
	}
	printf("rn");
}

void testLinkQueue() {
	int i = 10;
	CircleIntQueuePtr tempPtr = initQueue();
	for (; i < 16; i++) {
		enqueue(tempPtr, i);
	}//Of for i

	outputLinkQueue(tempPtr);

	for (i = 0; i < 6; i++) {
		printf("dequeue gets %drn", dequeue(tempPtr));
	}//Of for i

	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}//Of testLinkQueue


int main() {
	testLinkQueue();
	return 1;
}

运行结果：

Queue full
Queue full
Elements in the queue 10, 11, 12, 13,
dequeue gets 10
dequeue gets 11
dequeue gets 12
dequeue gets 13
No element in the queue
dequeue gets -1
No element in the queue
dequeue gets -1
Elements in the queue 8,