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

链队列

结构示意图 

 

代码 

#include<stdio.h>
#include<malloc.h>
 
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));
	
	LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof( LinkNodePtr));
	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("\r\n");
}
 
void enqueue(LinkQueuePtr paraQueuePtr,int paraElement) {
	LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof (struct LinkNode));
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	paraQueuePtr->rear->next = tempNodePtr;
	paraQueuePtr->rear = tempNodePtr; 
}
 
int dequeue(LinkQueuePtr paraQueuePtr) {
	int resultValue;
	LinkNodePtr tempNodePtr;
	
	if (paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is  empty !\n");
		return -1;
	}
	
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;
	
	if (paraQueuePtr->rear == tempNodePtr) {
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	
	free(tempNodePtr);
	tempNodePtr = NULL;
	
	return resultValue;
}
 
void testLinkQueue() {
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr,10);
	enqueue(tempQueuePtr,30);
	enqueue(tempQueuePtr,50);
	
	outputLinkQueue(tempQueuePtr);
	
	printf("dequeue gets %d\n",dequeue(tempQueuePtr)); 
	printf("dequeue gets %d\n",dequeue(tempQueuePtr));
	printf("dequeue gets %d\n",dequeue(tempQueuePtr));
	printf("dequeue gets %d\n",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

循环队列

代码

#include<stdio.h>
#include<malloc.h>
 
#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 full.\n");
		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 queue.\n");
		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.\n");
		return;
	}
	
	printf("Elements in the queue: \n");
	for (i = paraPtr->head; i < paraPtr->tail; i++) {
		printf("%d ",paraPtr->data[i % TOTAL_SPACE]);
	}
	
	printf("\r\n");
}
 
void testLinkQueue() {
	int i = 10;
	CircleIntQueuePtr tempPtr = initQueue();
	for (; i <16; i++) {
		enqueue(tempPtr,i);
	}
	
	outputLinkQueue(tempPtr);
	
	for (i = 0; i < 6; i++) {
		printf("Dequeue gets %d \n",dequeue(tempPtr));
	}
	
	enqueue(tempPtr,8);
	outputLinkQueue(tempPtr);
}
 
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