代码:
#include <stdio.h>
#include <malloc.h>
/**
* 链队列的节点.
*/
typedef struct LinkNode{
int data;
LinkNode* next;
}*LinkNodePtr;
/**
* 链队列.
*/
typedef struct LinkQueue{
LinkNodePtr front;
LinkNodePtr rear;
}*LinkQueuePtr;
/**
* Construct an empty queue.
*/
LinkQueuePtr initQueue(){
LinkQueuePtr resultPtr;
printf("In initQueue, the address of resultPtr is %d\r\n", &resultPtr);
resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));
printf("The value of resultPtr is %d\r\n", resultPtr);
//The header, the data is not useful.
LinkNodePtr headerPtr;
printf("The address of headerPtr is %d\r\n", &headerPtr);
headerPtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
printf("The value of headerPtr is %d\r\n", headerPtr);
headerPtr->next = NULL;
resultPtr->front = headerPtr;
resultPtr->rear = headerPtr;
return resultPtr;
}//Of initQueue
/**
* Construct an empty queue.
*/
void outputLinkQueue(LinkQueuePtr paraQueuePtr){
LinkNodePtr tempPtr;
printf("In printLinkQueue, the address of tempPtr is %d\r\n", &tempPtr);
tempPtr = paraQueuePtr->front->next;
printf("The value of tempPtr is %d\r\n", tempPtr);
printf("This is a queue: ");
while (tempPtr != NULL) {
printf("%d ", tempPtr->data);
tempPtr = tempPtr->next;
printf("The value of tempPtr is %d\r\n", tempPtr);
}//Of while
}//Of outputLinkQueue
/**
* Enqueue.
*/
void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
//Step 1. Create a new node
LinkNodePtr tempNodePtr;
printf("In linkEnqueue, the address of tempNodePtr is %d\r\n", &tempNodePtr);
tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
printf("The value of tempNodePtr is %d\r\n", tempNodePtr);
tempNodePtr->data = paraElement;
tempNodePtr->next = NULL;
//Step 2. Link to the existing rear
paraQueuePtr->rear->next = tempNodePtr;
//Step 3. It is the new rear
paraQueuePtr->rear = tempNodePtr;
}//Of enqueue
/**
* Dequeue.
* @return The value of the header
*/
int dequeue(LinkQueuePtr paraQueuePtr) {
int resultValue;
LinkNodePtr tempNodePtr;
//Step 1. Is the queue empty?
printf("dequeue test 1\r\n");
if (paraQueuePtr->front == paraQueuePtr->rear) {
printf("The queue is empty.\r\n");
return -1;
}//Of if
//Step 2. Change the queue.
printf("dequeue test 2\r\n");
tempNodePtr = paraQueuePtr->front->next;
resultValue = tempNodePtr->data;
paraQueuePtr->front->next = paraQueuePtr->front->next->next;
if (paraQueuePtr->rear == tempNodePtr) {
paraQueuePtr->rear = paraQueuePtr->front;
}//Of if
printf("dequeue test 3, the ptr is %d\r\n", tempNodePtr);
//Step 3. Free space.
//free(tempNodePtr);
//Step 4. Return.
printf("trying to dequeue %d\r\n", resultValue);
return resultValue;
}//Of enqueue
/**
* Unit test.
*/
void testLinkQueue(){
printf("Start testing.");
LinkQueuePtr tempQueuePtr;
tempQueuePtr = initQueue();
enqueue(tempQueuePtr, 10);
enqueue(tempQueuePtr, 30);
enqueue(tempQueuePtr, 50);
printf("Before outputLinkQueue.\r\n");
outputLinkQueue(tempQueuePtr);
printf("After outputLinkQueue.\r\n");
printf("dequeue gets %d", dequeue(tempQueuePtr));
printf("dequeue gets %d", dequeue(tempQueuePtr));
printf("dequeue gets %d", dequeue(tempQueuePtr));
printf("dequeue gets %d", dequeue(tempQueuePtr));
}//Of testLinkQueue
/**
* The entrance.
*/
int main(){
testLinkQueue();
return 1;
}//Of main
运行结果:
队列(queue)是一种先进先出的、操作受限的线性表。
队列这种数据结构非常容易理解,就像我们平时去超市买东西,在收银台结账的时候需要排队,先去排队的就先结账出去,排在后面的就后结账,有其他人再要过来结账,必须排在队尾不能在队中间插队。
「 队列 」数据结构就是这样的,先进入队列的先出去,后进入队列的后出去。必须从队尾插入新元素,队列中的元素只能从队首出,这也就是「 队列 」操作受限制的地方了。与堆栈类似,队列既可以用 「 数组 」 来实现,也可以用 「 链表 」 来实现。
用链表实现的队列,叫做 链式队列:
用链表来实现也比较简单,与数组实现类似,也是需要2个指针来控制(front和rear)。当进行入队操作时,让新节点的Next指向rear的Next,再让rear的Next指向新节点,最后让rear指针向后移动一位(即rear指针指向新节点)。
当进行出队操作时,直接将front指针指向的元素出队,同时让front指向下一个节点(即将front的Next赋值给front指针)。