Learning objectives: learn to be familiar with the operation queue
Study Guide: Fanshen's Code
Learning tasks:
- copy code
Learning Outcome Catalog
Code description:
queue list
- During operation, which variables are allocated in adjacent spaces? In the global area (static area), global variables and static variables are stored together. Initialized global variables and static variables are in one area, and uninitialized global variables and uninitialized static variables are in another adjacent area.
- Can the space of local variables be reused? for example. Yes, circular linked lists are.
- What is the difference between the address and value of a pointer? Passing the pointer pointer will not be changed, while passing the address, the content of the address will be changed
- The proposal of the queue is also complicated to obtain O(1) time.
circular queue
- The role of divisibility. (Necessary operation of the cycle)
- Imagine putting a team of people on the playground track, and the feeling of circulation will come out.
- In order to distinguish between an empty queue and a full queue, a space needs to be left. It is equivalent to not allowing end-to-end connection. Let’s draw a picture, otherwise it is easy to get into the pit.
- With a chain structure, the allocation and recovery of space is done by the system, and with a circular queue, it is controlled by yourself. Imagine that you are writing an operating system, and you can feel the memory management from this code.
study-time:
2022.5.6
1 chained queue
1.1 All codes
#include <stdio.h>
#include <malloc.h>
/**
* 链队列的节点.
*/
typedef struct LinkNode {
int data;
struct LinkNode* next;
}*LinkNodePtr, LinkNode;
/**
* 链队列.
*/
typedef struct LinkQueue {
LinkNodePtr front;
LinkNodePtr rear;
}*LinkQueuePtr, LinkQueue;
/**
* @brief 初始化队列
*
* @return 队列头节点
*/
LinkQueuePtr initQueue() {
//申请队列
LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(LinkQueue));
//申请头节点
LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(LinkNodePtr));
headerPtr->next = NULL;
resultPtr->front = headerPtr;
resultPtr->rear = headerPtr;
return resultPtr;
}
/**
* @brief 输出队列
*
* @param paraQueuePtr
*/
void outputLinkQueue(LinkQueuePtr paraQueuePtr) {
LinkNodePtr tempPtr = paraQueuePtr->front->next;
while (tempPtr != NULL) {
printf("%d ", tempPtr->data);
tempPtr = tempPtr->next;
}
printf("\n");
}
/**
* @brief 入队
*
* @param paraElement
* @param paraQueuePtr
*/
void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
//1申请新的节点
LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
tempNodePtr->data = paraElement;
tempNodePtr->next = NULL;
//2加入队列
paraQueuePtr->rear->next = tempNodePtr;
//3重置队尾
paraQueuePtr->rear = tempNodePtr;
printf("%d 入队\n",paraElement);
}
/**
* @brief 出队
*
* @param paraQueuePtr
*
* @return 出队的数据值
*/
int dequeue(LinkQueuePtr paraQueuePtr) {
int resultValue;
LinkNodePtr tempNodePtr;
//1判断队列是否为空
if (paraQueuePtr->front == paraQueuePtr->rear) {
printf("出队失败，队列为空.\n");
return -1;
}
//2改变队列
tempNodePtr = paraQueuePtr->front->next;
resultValue = tempNodePtr->data;
paraQueuePtr->front->next = paraQueuePtr->front->next->next;
if (paraQueuePtr->rear == tempNodePtr) {
paraQueuePtr->rear = paraQueuePtr->front;
}
//3释放出队的节点资源
free(tempNodePtr);
tempNodePtr = NULL;
//4返回出队值
return resultValue;
}
/**
* @brief 单元测试
*/
void testLinkQueue() {
printf("---- testLinkQueue 测试开始 ----\n");
LinkQueuePtr tempQueuePtr;
tempQueuePtr = initQueue();
enqueue(tempQueuePtr, 10);
enqueue(tempQueuePtr, 30);
enqueue(tempQueuePtr, 50);
printf("入队后队列为:\n");
outputLinkQueue(tempQueuePtr);
printf("出队 得到 %d\n", dequeue(tempQueuePtr));
printf("出队 得到 %d\n", dequeue(tempQueuePtr));
printf("出队 得到 %d\n", dequeue(tempQueuePtr));
printf("出队 得到 %d\n", dequeue(tempQueuePtr));
enqueue(tempQueuePtr, 8);
printf("入队后队列为:\n");
outputLinkQueue(tempQueuePtr);
printf("\n---- testLinkQueue 测试结束 ----\n");
}
/**
* @brief 主函数
*
* @return
*/
int main() {
testLinkQueue();
return 1;
}
1.2 Test results
---- testLinkQueue 测试开始 ----
10 入队
30 入队
50 入队
入队后队列为:
10 30 50
出队 得到 10
出队 得到 30
出队 得到 50
出队失败，队列为空.
出队 得到 -1
8 入队
入队后队列为:
8
---- testLinkQueue 测试结束 ----1.3 Graphical Queue
2 circular queues
2.1 All codes
#include <stdio.h>
#include <malloc.h>
#define TOTAL_SPACE 5
typedef struct CircleIntQueue{
int data[TOTAL_SPACE];
int head;
int tail;
}*CircleIntQueuePtr;
/**
* @brief 初始化队列
*
* @return
*/
CircleIntQueuePtr initQueue() {
CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
resultPtr->head = 0;
resultPtr->tail = 0;
return resultPtr;
}
/**
* @brief 入队
*
* @param paraPtr
* @param paraValue
*/
void enqueue(CircleIntQueuePtr paraPtr, int paraValue) {
if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) {
printf("入队失败，队满.\n");
return;
}
paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
paraPtr->tail++;
}
/**
* @brief 出队
*
* @param paraPtr
*
* @return
*/
int dequeue(CircleIntQueuePtr paraPtr) {
int resultValue;
if (paraPtr->head == paraPtr->tail) {
printf("出队失败，队空.\r\n");
return -1;
}
resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
paraPtr->head++;
return resultValue;
}
/**
* @brief 打印队列
*
* @param paraPtr
*/
void outputLinkQueue(CircleIntQueuePtr paraPtr){
int i;
if (paraPtr->head == paraPtr->tail) {
printf("打印队列失败，队空");
return;
}
printf("队中元素有: ");
for (i = paraPtr->head; i < paraPtr->tail; i++) {
printf("%d ", paraPtr->data[i % TOTAL_SPACE]);
}
printf("\n");
}
/**
* @brief 单元测试
*/
void testLinkQueue(){
printf("---- testLinkQueue 测试开始 ----\n");
int i = 10;
CircleIntQueuePtr tempPtr = initQueue();
for (; i < 16; i ++) {
enqueue(tempPtr, i);
}
outputLinkQueue(tempPtr);
for (i = 0; i < 6; i ++) {
int flag=dequeue(tempPtr);
if(flag==-1){
break;
}else printf("出队 得到%d\n", flag);
}
enqueue(tempPtr, 8);
outputLinkQueue(tempPtr);
printf("---- testLinkQueue 测试结束 ----\n");
}
int main(){
testLinkQueue();
return 1;
}
2.2 Test results
---- testLinkQueue 测试开始 ----
入队失败，队满.
入队失败，队满.
队中元素有: 10 11 12 13
出队 得到10
出队 得到11
出队 得到12
出队 得到13
出队失败，队空.
队中元素有: 8
---- testLinkQueue 测试结束 ----
2.3 Graphical Circular Queue
