C语言数据结构之队列与链表
参考链接：https://blog.csdn.net/Ceosat/article/details/103890562?fromshare=blogdetail&sharetype=blogdetail&sharerId=103890562&sharerefer=PC&sharesource=welclose&sharefrom=from_link
1 基本概念对比
- 链表（List）：由一系列节点组成，每个节点包含数据和指向下一个（或前后）节点的指针。节点动态分配，长度可变。
- 常见类型：单向链表（singly）、双向链表（doubly）、循环链表（circular）。
- 用途：需要频繁在中间插入/删除的场景很合适。
- 队列（Queue）：一种抽象数据类型（ADT），遵循 FIFO（先进先出）规则。只在队尾插入（enqueue），只在队头删除（dequeue）。
- 队列可以用数组（循环缓冲）或链表实现
2 操作与时间复杂度
| 操作 | 链表（单向） | 双向链表 | 数组（动态/环形） |
|---|---|---|---|
| 插入头 | O(1) | O(1) | O(n)（通常需要移动或重新分配） |
| 插入尾 | O(n)（无尾指针）/O(1)（有尾指针） | O(1) | O(1) amortized（动态数组尾插）或 O(1)（环形缓冲） |
| 删除任意节点 | O(n)（需找到前驱） | O(1)（已知节点） | O(n) |
| 查找（按值） | O(n) | O(n) | O(n) |
| 随机访问 | O(n) | O(n) | O(1) |
队列常用操作：
enqueue（入队） — 插入到队尾dequeue（出队） — 从队头删除并返回元素peek/front— 查看队头但不删除isEmpty,isFull（针对数组实现）
3 链表（以单向链表为例）
3.1 节点定义如下
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int dat;
struct Node *pNext;
} Node, *pNode;
这是c语言的结构体定义，其中：
struct Node 是结构体类型名（C 风格的名字）。
typedef ... Node 让你可以直接写 Node 代替 struct Node。
typedef ... *pNode 让你可以写 pNode 表示 struct Node *（即指向 Node 的指针）。
我们在使用结构体的时候，注意数据本身是int data，而指向下一个节点的pNode一定要是个Node指针，如果pNode仍然还是一个int类型，会出现无限递归、无法出现动态链接、无法表示链表结束等问题（即区分.运算符和->运算符的区别）。
3.2 创建节点
pNode create_node(int value) { //创建一个节点
pNode p = (pNode)malloc(sizeof(Node)); //分配节点
if (!p) { //判断是否能分配
perror("malloc");
exit(EXIT_FAILURE);
}
p->dat = value;//存入节点值
p->pNext = NULL;//新节点默认的指针是空指针
return p;
}
3.3 插入首结点
pNode insert_head(pNode head, int value) {//插入首结点
pNode node = create_node(value);
node->pNext = head;//新结点的 next 指向原来的头
return node;//返回新头结点
}
3.4 插入尾结点
pNode insert_tail(pNode head, int value) {//插入尾结点
pNode node = create_node(value); // 创建新结点
// 若链表为空，新结点即为头结点
if (head == NULL) return node;
// 否则找到最后一个结点
pNode cur = head;
while (cur->pNext != NULL)
cur = cur->pNext;
// 最后结点的 next 指向新结点
cur->pNext = node;
return head; // 头指针不变
}
3.5 查找值为value的第一个结点（从头开始找）
pNode find_node(pNode head, int value) {
pNode cur = head;
while (cur != NULL) {
if (cur->dat == value)
return cur; // 找到立即返回
cur = cur->pNext;
}
return NULL; // 未找到
}
3.6 删除值为value的第一个结点（从头开始找）
pNode delete_node(pNode head, int value) {
if (head == NULL) return NULL; // 空链表直接返回
// 如果要删除的是头结点
if (head->dat == value) {
pNode tmp = head->pNext;
free(head); // 释放原头
return tmp; // 新头为原头的下一个
}
// 否则，查找要删除的结点及其前驱
pNode prev = head;
pNode cur = head->pNext;
while (cur != NULL) {
if (cur->dat == value) {
prev->pNext = cur->pNext; // 前驱跳过当前结点
free(cur); // 释放当前结点
return head; // 返回原头
}
prev = cur;
cur = cur->pNext;
}
return head; // 未找到要删除的结点
}
3.7 遍历链表并输出所有结点值
void traverse(pNode head) {
pNode cur = head;
printf("链表内容：");
while (cur != NULL) {
printf("%d -> ", cur->dat);
cur = cur->pNext;
}
printf("NULL\n");
}
3.8 释放整个链表所占内存
void free_list(pNode head) {
pNode cur = head;
while (cur != NULL) {
pNode tmp = cur->pNext; // 记录下一个结点
free(cur); // 释放当前结点
cur = tmp; // 移动到下一个
}
}
3.9 测试程序
int main(void) {
pNode head = NULL; // 初始化空链表
// 插入几个结点
head = insert_head(head, 3);
head = insert_head(head, 2);
head = insert_tail(head, 4);
head = insert_tail(head, 5);
traverse(head); // 输出：2 -> 3 -> 4 -> 5 -> NULL
// 删除一个结点
head = delete_node(head, 3);
traverse(head); // 输出：2 -> 4 -> 5 -> NULL
// 查找结点
pNode found = find_node(head, 4);
if (found) printf("找到结点，值为：%d\n", found->dat);
else printf("未找到目标结点。\n");
// 释放链表
free_list(head);
return 0;
}
4 链表实现队列
4.1 结点定义
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/* -----------------------------
队列节点定义
----------------------------- */
typedef struct Node {
int dat; // 数据域
struct Node *pNext; // 指向下一个节点
} Node, *pNode;
/* -----------------------------
链式队列结构体定义
front 指向队头（出队）
rear 指向队尾（入队）
----------------------------- */
typedef struct {
pNode front;
pNode rear;
} LinkedQueue;
4.2 创建一个空队列
LinkedQueue* create_queue(void) {
LinkedQueue *q = (LinkedQueue*)malloc(sizeof(LinkedQueue));
if (!q) {
perror("malloc 失败");
exit(EXIT_FAILURE);
}
q->front = q->rear = NULL; // 初始为空队列
return q;
}
4.3 判断队列是否为空
bool is_empty(LinkedQueue *q) {
return q->front == NULL;
}
4.4 入列操作
队列遵循先进先出（FIFO）的原则，所以入队在队列的最后一位元素后添加，然后队尾往后移动一位。
void enqueue(LinkedQueue *q, int value) {
pNode node = (pNode)malloc(sizeof(Node));
if (!node) {
perror("malloc 失败");
exit(EXIT_FAILURE);
}
node->dat = value;
node->pNext = NULL;
if (q->rear == NULL) {
// 队列为空，front 和 rear 都指向新节点
q->front = q->rear = node;
} else {
// 队列非空，rear->next 指向新节点
q->rear->pNext = node;
q->rear = node; // rear 后移
}
}
4.5 从队头删除元素
队列遵循先进先出（FIFO）的原则，所以出队是第一个元素出来，然后队头往后移动一位。
bool dequeue(LinkedQueue *q, int *out) {
if (is_empty(q)) {
printf("队列为空，无法出队。\n");
return false;
}
pNode tmp = q->front; // 临时保存头节点
*out = tmp->dat; // 取出数据
q->front = tmp->pNext; // 队头后移
// 如果出队后队列为空，rear 也要置空
if (q->front == NULL)
q->rear = NULL;
free(tmp); // 释放旧的头节点
return true;
}
4.6 打印当前队列内容
void print_queue(LinkedQueue *q) {
pNode cur = q->front;
printf("队列内容：");
while (cur != NULL) {
printf("%d -> ", cur->dat);
cur = cur->pNext;
}
printf("NULL\n");
}
4.7 释放整个队列的内存
void free_queue(LinkedQueue *q) {
int tmp;
while (dequeue(q, &tmp)); // 不断出队直到为空
free(q); // 最后释放队列结构本身
}
4.8 测试函数
int main(void) {
LinkedQueue *q = create_queue(); // 创建空队列
enqueue(q, 10);
enqueue(q, 20);
enqueue(q, 30);
print_queue(q); // 输出：10 -> 20 -> 30 -> NULL
int x;
dequeue(q, &x);
printf("出队元素：%d\n", x); // 输出：出队元素：10
print_queue(q); // 输出：20 -> 30 -> NULL
free_queue(q); // 释放内存
return 0;
}
5 注意要点
-
创建节点一定要用指针。
在3.1中提到，创建节点的时候使用的是指针。
-
在进行删除链表节点时，需要free掉原本分配的内存。
可以发现，在链表和链表构成的队列中，都有
free的操作。如果不进行free就退出删除元素的函数，就会使这块内存（要删除元素所在的内存）无法被释放，也就是造成了内存泄漏，这是不允许的。为什么说无法被释放了呢，我们的链表创建节点时用
malloc函数请求分配一块内存（申请的内存在堆里），这块内存存在堆中，不会像栈一样在生命周期结束由系统自动回收（栈存储下一条执行指令和局部变量，本人理解可能不准确）。 -
函数返回的pNode（数据类型，Node类型的指针）都是由malloc分配的。
这是为什么呢？原来也是和1相似的原因。如果我们直接使用
pNode tmp = q->front; // 临时保存头节点创建的局部变量而不是使用malloc创建的pNode作为返回变量进行return。那么返回的pNode在函数结束后，它指向的局部变量会被系统自动回收，pNode存的就是非法的地址（pNode可能指向了某个随机值，这不是我们想要的），此时的pNode就称为野指针，这是我们不想看到的。
扫一扫
2711
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
