3.6链队列

链队列代码

#include<stdio.h>
#include<malloc.h>

/**
  * 链队列的节点 
  */
  typedef struct LinkNode {
	int data;
	struct LinkNode* next;
  } *LinkNodePtr;
  
/**
  * 链队列 
  */ 
  typedef struct LinkQueue {
	LinkNodePtr front;
	LinkNodePtr rear;
  } *LinkQueuePtr;
  
/**
  * Construct an empty queue.
  */ 
  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;
  }//Of initQueue
  
/**
  * Output the queue.（输出队列所有元素） 
  */
  void outputLinkQueue(LinkQueuePtr paraQueuePtr) {
	LinkNodePtr tempPtr = paraQueuePtr->front->next;
	if(tempPtr != NULL) {
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	} else {
		printf("The queue is empty now.\r\n");
	}//Of if
	printf("\r\n");
  }//Of outputLinkQueue
  
/**
  * Enqueue.(入队)
  */
  void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	// Step 1. Create a new code.
	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. 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?
	if(paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is empty.\r\n");
		return -1;
	}//Of if
	
	// 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;
	}//Of if
	
	// Step 3. Free space.
	free(tempNodePtr);
//	tempNodePtr = NULL;
	
	// Step 4. Return.
	return resultValue;
  }//Of dequeue
  
/**
  * Unit test.
  */
  void testLinkQueue() {
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 10);
	enqueue(tempQueuePtr, 30);
	enqueue(tempQueuePtr, 50);
	
	outputLinkQueue(tempQueuePtr);
	
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	outputLinkQueue(tempQueuePtr);
	
	enqueue(tempQueuePtr, 8);
	outputLinkQueue(tempQueuePtr);
  }//Of testLinkQueue

/**
  * The entrance.
  */
  int main() {
  	testLinkQueue();
  	return 1;
  }//Of main

运行结果

代码分析

入队代码：

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	// Step 1. Create a new code.
	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. It is the new rear.
	paraQueuePtr->rear = tempNodePtr;
  }//Of enqueue

首先创建一个节点存放新的数据，通过rear指针找到添加节点的位置，再将rear指针指向新添加的节点作为尾节点

出队：

int dequeue(LinkQueuePtr paraQueuePtr) {
	int resultValue;
	LinkNodePtr tempNodePtr;
	
	// Step 1. Is the queue empty?
	if(paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is empty.\r\n");
		return -1;
	}//Of if
	
	// 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;
	}//Of if
	
	// Step 3. Free space.
	free(tempNodePtr);
//	tempNodePtr = NULL;
	
	// Step 4. Return.
	return resultValue;
  }//Of dequeue

因为队列是先进先出的，所以首先通过front节点找到第一个存放有效数据的节点，用tempNodePtr存放起来，便于后续说明和释放（free），再将front指针指向第二个存放有效数据的节点，最后释放tempNodePtr

心得体会

队列是先进先出的线性数据结构，且这个数据结构只允许在一端进行插入，另一端进行删除，禁止直接访问除这两端以外的一切数据，链队列是在链表的基础上实现的队列结构，链队列的头部删除和尾部插入的时间复杂度均为O(1),而如果只是一个单链表，尾部删除的时间复杂度为O(n),这也是队列的一个优点。