本文转自 https://blog.csdn.net/lym152898/article/details/52202606 ### 队列的基本概念 队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。 队首 (front) :允许进行删除的一端称为队首。 队尾 (rear) :允许进行插入的一端称为队尾。 队列中没有元素时称为空队列。在空队列中依次加入元素 a 1 , a 2 , …, a n 之后, a 1 是队首元素, a n 是队尾元素。显然退出队列的次序也只能是 a 1 , a 2 , …, a n ,即队列的修改是依先进先出的原则进行的下图所示。 ![](https://box.kancloud.cn/84dbaaef6ee9d1ee482ca56db7de8159_531x134.jpg) ### 队列的基本操作 1. 创建新队列 2. 判空 3. 进队 4. 出队 5. 清空队 6. 获得队头元素 7. 遍历队 8. 销毁队 9. 队长 ### 顺序队列 利用一组连续的存储单元 ( 一维数组 ) 依次存放从队首到队尾的各个元素,称为顺序队列。对于队列,和顺序栈相类似,也有动态和静态之分。 这里介绍静态顺序队列.其类型定义如下: typedef int datatype; #define MAX_QUEUE_SIZE 100 typedef struct queue { datatype queue_array[MAX_QUEUE_SIZE]; int front; int rear; }sp_queue; 设立一个队首指针 front ,一个队尾指针rear ,分别指向队首和队尾元素。 * 初始化: front=rear =0。 * 入队:将新元素插入 rear 所指的位置,然后rear 加 1 。 * 出队:删去 front 所指的元素,然后加 1 并返回被删元素。 * 队列为空: front=rear 。 * 队满: rear = MAX_QUEUE_SIZE - 1 或front=rear 。 在非空队列里,队首指针始终指向队头元素,而队尾指针始终指向队尾元素的下一位置。顺序队列中存在“假溢出”现象。因为在入队和出队操作中,头、尾指针只增加不减小,致使被删除元素的空间永远无法重新利用。因此,尽管队列中实际元素个数可能远远小于数组大小,但可能由于尾指针巳超出向量空间的上界而不能做入队操作。该现象称为假溢出。如图 3-6 所示是数组大小为 5 的顺序队列中队首、队尾指针和队列中元素的变化情况。 ![](https://box.kancloud.cn/aa1719449f88f6d50b4ca1aa19a9ef48_542x186.jpg) ### 代码实现 /* 顺序队列接口定义头文件*/ #define true 1 #define false 0 /* 队的最大长度 */ #define MAX_QUEUE_SIZE 100 /* 队列的数据类型 */ typedef int datatype; /* 静态链的数据结构 */ typedef struct queue{ datatype sp_queue_array[MAX_QUEUE_SIZE]; /* 队头 */ int front; /* 队尾 */ int rear; }sp_queue; /* 静态顺序链的接口定义 */ /* 静态链的初始化 */ sp_queue queue_init(); /* 判断队列是否为空,若为空 * 返回true * 否则返回false */ int queue_empty(sp_queue q); /* 插入元素e为队q的队尾新元素 * 插入成功返回true * 队满返回false */ int queue_en(sp_queue *q, datatype e); /* 队头元素出队 * 用e返回出队元素,并返回true * 若队空返回false */ int queue_de(sp_queue *q, datatype *e); /* 清空队 */ void queue_clear(sp_queue *q); /* 获得队头元素 * 队列非空,用e返回队头元素,并返回true * 否则返回false */ int get_front(sp_queue, datatype *e ); /* 获得队长 */ int queue_len(sp_queue q); /* 遍历队 */ void queue_traverse(sp_queue q, void(*visit)(sp_queue q)); void visit(sp_queue s); /* 接口实现文件 */ #include<stdio.h> #include<stdlib.h> #include"sp_queue.h" sp_queue queue_init() { sp_queue q; q.front = q.rear = 0; return q; } int queue_empty(sp_queue q) { return q.front == q.rear; } int queue_en(sp_queue *q, datatype e) { /* 队满 */ if (q -> rear == MAX_QUEUE_SIZE) return false; /* 入队 */ q -> sp_queue_array[q -> rear] = e; printf("q.sp_queue_array[%d]=%d\n", q -> rear, e); q -> rear += 1; return true; } int queue_de(sp_queue *q, datatype *e) { /* 队空 */ if(queue_empty(*q)) return false; /* 出队 */ q -> rear -= 1; *e = q -> sp_queue_array[q -> rear]; return true; } void queue_clear(sp_queue *q) { q -> front = q -> rear = 0; } int get_front(sp_queue q, datatype *e) { /* 队空 */ if(q.front == q.rear) return false; /* 获取队头元素 */ *e = q.sp_queue_array[q.front]; return true; } int queue_len(sp_queue q) { return (q.rear - q.front); } void queue_traverse(sp_queue q, void (*visit)(sp_queue q)) { visit(q); } void visit(sp_queue q) { /* 队空 */ if (q.front == q.rear) printf("队列为空\n"); int temp = q.front; while(temp != q.rear) { printf("%d ",q.sp_queue_array[temp]); temp += 1; } printf("\n"); } int main() { sp_queue q = queue_init(); queue_en(&q, 1); queue_en(&q, 2); printf("length=%d\n", queue_len(q)); queue_en(&q, 3); printf("length=%d\n", queue_len(q)); queue_en(&q, 4); printf("length=%d\n", queue_len(q)); queue_en(&q, 5); printf("length=%d\n", queue_len(q)); queue_en(&q, 6); printf("length=%d\n", queue_len(q)); queue_traverse(q,visit); datatype *e = (datatype *)malloc(sizeof(*e)); queue_de(&q,e); printf("queue_de(),e=%d length=%d\n", *e, queue_len(q)); queue_traverse(q, visit); queue_clear(&q); queue_traverse(q, visit); printf("length:%d\n", queue_len(q)); } 注意:结构体变量作为函数的参数和其他普通变量一样,值只会在函数体内被修改,想要通过函数更改结构体的值,可以通过结构体指针作为函数的参数实现. ### 队列的链式表示和实现 队列的链式存储结构简称为链队列,它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。需要两类不同的结点:数据元素结点,队列的队 首指针和队尾指针的结点,如图 3-8 所示。 ![](https://box.kancloud.cn/9c10054fd3394600c265365c1125d55e_265x131.jpg) 数据元素结点类型定义: typedef struct q_node{ datatype data; struct q_node *next; }q_node; 指针结点类型: typedef struct { q_node *front; q_node *rear; }link_queue; ### 链队运算及指针变化 链队的操作实际上是单链表的操作,只不过是删除 在表头进行,插入在表尾进行。插入、删除时分别修改 不同的指针。链队运算及指针变化如图 3-9 所示。 ![](https://box.kancloud.cn/bcb178589d9b0fe0f241fa0ecb162644_919x648.jpg) ### 代码实现 /* 链式栈接口的定义头文件 */ #define true 1 #define false 0 /* 队列的数据类型 */ typedef int datatype; /* 静态链的数据结构 */ typedef struct q_node{ datatype data; struct q_node *next; }q_node,*link_node; typedef struct l_queue{ /* 队头指针 */ q_node *front; /* 队尾指针 */ q_node *rear; }*link_queue; /* 静态顺序链的接口定义 */ /* 静态链的初始化 */ link_queue queue_init(); /* 判断队列是否为空,若为空 * 返回true * 否则返回false */ int queue_empty(link_queue q); /* 插入元素e为队q的队尾新元素 * 插入成功返回true * 队满返回false */ int queue_en(link_queue q, datatype e); /* 队头元素出队 * 用e返回出队元素,并返回true * 若队空返回false */ int queue_de(link_queue q, datatype *e); /* 清空队 */ void queue_clear(link_queue q); /* 销毁队 */ void queue_destroy(link_queue q); /* 获得队头元素 * 队列非空,用e返回队头元素,并返回true * 否则返回false */ int get_front(link_queue q, datatype *e ); /* 获得队长 */ int queue_len(link_queue q); /* 遍历队 */ void queue_traverse(link_queue q, void(*visit)(link_queue q)); void visit(link_queue q); /* 接口的实现文件 */ #include<stdio.h> #include<stdlib.h> #include"lp_queue.h" link_queue queue_init() { /* 新建头结点 */ link_node new_node = (link_node)malloc(sizeof(q_node)); new_node -> next = NULL; /* 指针结点 */ link_queue q = (link_queue)malloc(sizeof(*q)); q -> front = q -> rear = new_node; return q; } int queue_empty(link_queue q) { return q -> front == q -> rear; } int queue_en(link_queue q, datatype e) { /* 新建数据结点 */ link_node new_node = (link_node)malloc(sizeof(q_node)); /* 内存分配失败 */ if(!new_node) return false; new_node -> data = e; q -> rear -> next = new_node; q -> rear = new_node; return true; } int queue_de(link_queue q, datatype *e) { /* 队列为空 */ if (q -> front == q -> rear) return false; *e = q -> front -> next -> data; link_node temp = q -> front -> next; q -> front -> next = temp -> next; /* 防止丢失尾指针 */ if (temp == q.rear -> next) q -> rear = q -> front; free(temp); temp = NULL; return true; } void queue_clear(link_queue q) { /* 头结点 */ link_node head = q -> front -> next; head -> next = NULL; q -> front = q -> rear = head; /* 第一个结点 */ link_node temp = head -> next; while(temp) { link_node p = temp; temp = p -> next; free(p); p = NULL; } } void queue_destroy(link_queue q) { queue_clear(q); free(q); q = NULL; } int get_front(link_queue q, datatype *e) { /* 队为空 */ if (q -> front == q -> rear) return false; *e = q -> front -> next -> data; link_node temp = q -> front -> next; q -> front -> next = temp -> next; free(temp); temp = NULL; return true; } int queue_len(link_queue q) { /* 头结点 */ link_node p = q -> front -> next; /* 计数器 */ int count = 0; while(p) { count += 1; p = p -> next; } return count; } void queue_traverse(link_queue q, void(*visit)(link_queue q)) { visit(q); } void visit(link_queue q) { /* 头结点 */ link_node p = q -> front -> next; if(!p) { printf("队列为空"); } while(p) { printf("%d ", p -> data); p = p -> next; } printf("\n"); } int main() { link_queue q = queue_init(); queue_en(q, 1); queue_en(q, 2); printf("length=%d\n", queue_len(q)); queue_en(q, 3); printf("length=%d\n", queue_len(q)); queue_en(q, 4); printf("length=%d\n", queue_len(q)); queue_en(q, 5); printf("length=%d\n", queue_len(q)); queue_en(q, 6); printf("length=%d\n", queue_len(q)); queue_traverse(q,visit); datatype *e = (datatype *)malloc(sizeof(*e)); queue_de(q,e); printf("queue_de(),e=%d length=%d\n", *e, queue_len(q)); queue_traverse(q, visit); queue_clear(q); queue_traverse(q, visit); printf("length:%d\n", queue_len(q)); } 执行结果: ![](https://box.kancloud.cn/af4e03bc70d4539c3e854233624b4875_1251x273.jpg)