深入栈与队列的概念和底层结构实现（数组 vs 链表）

原创 于 2026-06-20 16:54:53 发布 · 250 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#c语言 #数据结构
话题
#编程达人挑战赛·第10期

在这里插入图片描述

名称：Doubletful的博客
💠数据结构专栏
签名：路漫漫其修远兮，吾将上下而求索

文章目录

前言

——栈和队列是计算机科学中最基础、最常用的两种抽象数据类型。几乎每个程序员都能随口说出“栈是后进先出（LIFO），队列是先进先出（FIFO）”，但在实际工程中，选择数组还是链表作为底层容器，会显著影响性能、内存占用和代码复杂度。
本期将使用C语言实现栈和队列，其主要内容包括：
1.使用头文件声明、源文件定义的形式呈现源码
2.介绍栈与队列的概念，并使用数组实现栈，链表实现队列
3.提供图例和使用链表实现栈，数组实现队列的对比表格

栈专题

一、概念

——栈是一种操作受限的线性表，只允许在固定一端进行插入和删除数据操作，进行插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据遵循后进先出原则(LIFO:List In First Out)
栈的插入操作被称为：进栈，入栈，压栈，在栈顶插入
栈的删除操作被称为：出栈，在栈顶删除
生活中的实例：空羽毛球桶，第一个被放入的羽毛球最后一个被取出，最后一个被放入的羽毛球第一个被取出(在不暴力拆除桶底的情况下(￣▽￣)")
注：说了这么多，但总结来看数据结构栈的本质还是数组，只是操作受限
数据结构栈的物理结构和逻辑结构示例图：
在这里插入图片描述

二、代码实现

准备

前置知识：

  • assert()函数介绍
    C语言标准库中的调试宏，用于在程序运行时检查条件是否成立。若条件为假（0），则输出错误信息（文件、行号、表达式）并调用 abort() 终止程序，若条件为真（非0），则无动作。常用于捕捉“不可能发生”的逻辑错误、验证函数前置条件等
  • perror()函数介绍
    C 语言标准库函数，用于打印错误信息。调用格式：perror(“前缀字符串”)，输出格式为“前缀字符串：错误原因\n”，常用于系统调用或库函数失败后，快速定位错误原因
  • exit()函数介绍
    C 语言标准库函数，用于正常终止程序。刷新所有输出缓冲区、关闭已打开的流。将退出状态码返回给操作系统（0 or EXIT_SUCCESS 表示成功，-1 or EXIT_FAILURE 表示失败）
  • 布尔值
    C语言并不自带布尔值作为内置数据类型，使用需引入标准库<stdbool.h>

头文件内容总览

注：代码部分如果直接复制不能成功运行，请将所有中文前的#替换为//

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int STDataType;

#栈
typedef struct Stack
{
	STDataType* arr;
	int top;
	int capacity;
}ST;

#初始化栈
void STInit(ST* pst);

#添加：入栈
void STPush(ST* pst, STDataType x);

#删除：出栈
void STPop(ST* pst);

#获取栈顶元素
STDataType STTop(ST* pst);

#判断是否为空
bool STEmpty(ST* pst);

#获取元素个数
int STSize(ST* pst);

#销毁栈
void STDestroy(ST* pst);

栈的属性有使用动态开辟的数组 arr，用于指向栈顶的指针 top 和用于存储数组当前容量的 capacity。栈从逻辑上操作受限，因此除基础的初始化和销毁外只能从栈顶入栈和出栈，不能在指定位置插入或删除元素，也只能获取当前栈顶的元素。除此之外还有两个判断栈信息的函数用于确定栈是否为空以及返回当前栈内的元素个数

初始化

void STInit(ST* pst)
{
	assert(pst);
	pst->arr = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

传入栈，并断言传入的指针不为 NULL
关于 top 的初始化有一个重要的点涉及到后续操作的逻辑控制，如果 top 指向栈顶，则需将 top 初始化为 -1，如果初始化为零会出现 top 为零时无法判断当前栈中是否还有元素的问题。如果 top 指向栈顶元素的下一个位置，就将其初始化为零，这种写法便于判满、入栈和返回元素个数

判断空间容量

void STCheckCapacity(ST* pst)
{
	if (pst->top == pst->capacity)
	{
		int newcapacity = (pst->capacity == 0 ? 4 : pst->capacity * 2);
		STDataType* tmp = (STDataType*)realloc(pst->arr, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
}

当 top 等于 capacity 时需动态扩容，当第一次扩容时初始化容量为4，否则扩容为当前容量的二倍，扩容后需判断是否扩容成功，失败返回提示信息后退出程序，成功时再执行更新操作

添加：入栈

void STPush(ST* pst, STDataType x)
{
	assert(pst);
	STCheckCapacity(pst);
	#入栈
	pst->arr[pst->top++] = x;
}

在这里插入图片描述
传入栈与要添加的元素，断言传入指针不为 NULL，判断容量
与顺序表相同，在数组尾插数据并让 top++

删除：出栈

void STPop(ST* pst)
{
	assert(pst && pst->top);
	#出栈
	pst->top--;
}

在这里插入图片描述
传入栈，断言传入指针不为 NULL 且栈中元素个数不为0
与顺序表相同，使 top-- 就能达到逻辑删除

获取栈顶元素

STDataType STTop(ST* pst)
{
	assert(pst && pst->top);
	#获取栈顶元素
	return pst->arr[pst->top - 1];
}

传入栈，断言传入指针不为 NULL 且栈中元素个数不为0
top 指向栈顶的下一个位置，可以利用 top - 1 找到并返回栈顶元素

判断是否为空

bool STEmpty(ST* pst)
{
	assert(pst);
	#判断是否为空
	return pst->top == 0;
}

传入栈，断言传入指针不为 NULL
在数组中，能根据每个元素的下标位置确定在这个元素前还有几个元素，例如下标为3的元素，它的前面就刚好有3个值，所以，我们同样可以根据 top 是否指向栈底判断栈是否为空，为空返回 true，否则返回 false

获取元素个数

int STSize(ST* pst)
{
	assert(pst);
	#获取元素个数
	return pst->top;
}

传入栈，断言传入指针不为 NULL
同上，top 指向栈顶元素的下一个位置，因此就为当前栈中的元素个数

销毁栈

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->arr);
	pst->arr = NULL;
	pst->top = pst->capacity = 0;
}

传入栈，断言传入指针不为 NULL
释放栈在堆区开辟的动态空间并将指针初始化，初始化 top 和容量

一份测试代码

void Test_Stack()
{
	ST s;
	#初始化测试
	STInit(&s);
	#入栈测试
	STPush(&s, 4);
	STPush(&s, 3);
	STPush(&s, 2);
	STPush(&s, 1);
	#出栈测试
	STPop(&s);
	STPop(&s);
	#获取栈顶元素测试
	printf("%d\n", STTop(&s));
	#判断是否为空测试
	printf("%d\n", STEmpty(&s));
	#获取元素个数测试
	printf("%d\n", STSize(&s));
	#销毁测试
	STDestroy(&s);
}

总结

数组实现栈的优缺点：

维度分析
时间复杂度所有操作均为O(1)
空间复杂度O(N)，但存在一定的容量预留，可能导致空间浪费
缓存命中率极好，连续内存，CPU 预加载效率高
扩容成本动态扩容时需复制整个数组，单次操作 O(N)，但均摊后很低
适用场景频繁压栈弹栈、对速度要求极高、元素数量可预估的场景

队列专题

一、概念

——队列也是一种操作受限的线性表，只允许在固定一端进行插入数据操作，另一端进行删除数据操作，插入数据的一端称为队尾，删除数据的一端称为队头，队列中的数据遵循先进先出的原则(FIFO:First In First Out)
队列的插入操作被称为：入队，在队尾插入
队列的删除操作被称为：出队，在队头删除
生活中的实例：排队购买，先来的人先买到票后从队头离开，后来的人排在队尾等待，整个流程有序进行(没有人插队的情况)
数据结构队列的物理结构和逻辑结构示例图：
在这里插入图片描述

二、代码实现

头文件内容总览

注：代码部分如果直接复制不能成功运行，请将所有中文前的#替换为//

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int QDataType;

#定义队列的节点结构
typedef struct QueueNode
{
	QDataType data; #存储值
	struct QueueNode* next; #指向下一个节点的指针
}QNode;

#定义存储队列信息的结构
typedef struct Queue
{
	QNode* phead; #指向队头的指针
	QNode* ptail; #指向队尾的指针
	int size; #当前的元素个数
}Queue;

#初始化队列
void QueueInit(Queue* pq);

#添加：入队
void QNodePush(Queue* pq, QDataType x);

#删除：出队
void QNodePop(Queue* pq);

#获取队头数据
QDataType QueueFront(Queue* pq);

#获取队尾数据
QDataType QueueBack(Queue* pq);

#判断是否为空
bool QueueEmpty(Queue* pq);

#获取元素个数
int QSize(Queue* pq);

#销毁队列
void QueueDestroy(Queue* pq);

从代码看，队列无疑多用了一个结构体用于实现完整结构，该结构的作用在于明确队头和队尾在物理存储结构中的位置，使我们无需考虑操作物理结构链表时执行的额外操作，只需将重点放在对队列的操作逻辑上。与此同时，我们注意到队列中有一个名为 QSize 的函数用于获取当前队列中的元素个数，我们知道，统计整条链表的元素个数需要完整遍历获得，单次操作的时间复杂度为O(N)，为高效可以在 Queue 结构体中额外维护一个变量 size 用于记录队列中的元素个数，使 QSize 函数的时间复杂度优化为O(1)

初始化

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

传入队列，并断言传入的指针不为 NULL
当前队列中无节点，因此将队头指针和队尾指针都置空，并使 size 初始化为0

添加：入队

void QNodePush(Queue* pq, QDataType x)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	#入队
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

在这里插入图片描述
传入队列与要添加的元素，断言传入指针不为 NULL，创建新节点
分为两种情况，当队列中无任何元素时，应该将队头指针与队尾指针同时指向入队节点，否则就使当前队尾元素的 next 指向入队节点后，修改队尾指针

删除：出队

void QNodePop(Queue* pq)
{
	assert(pq && pq->size);
	#出队
	#队列元素为1时删除导致队尾指针为野指针
	QNode* next = pq->phead->next;
	free(pq->phead);
	if (next == NULL)
		pq->phead = pq->ptail = next;
	else
		pq->phead = next;
	pq->size--;
}

在这里插入图片描述
传入队列，断言传入指针不为 NULL 且队列元素个数不为0
分为队列元素个数为1和不为1两种情况，为1时在销毁队头指针指向的节点后需同时修改头尾指针指向为 NULL，不为1时只修改队头指针指向

获取队头数据

QDataType QueueFront(Queue* pq)
{
	assert(pq && pq->size);
	#获取队头数据
	return pq->phead->data;
}

传入队列，断言传入指针不为 NULL 且队列元素个数不为0
直接通过队头指针返回第一个元素

获取队尾数据

QDataType QueueBack(Queue* pq)
{
	assert(pq && pq->size);
	#获取队尾数据
	return pq->ptail->data;
}

传入队列，断言传入指针不为 NULL 且队列元素个数不为0
通过队尾指针返回最后一个元素

判断是否为空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	#判断是否为空
	return pq->size == 0;
}

传入队列，断言传入指针不为 NULL
通过维护的变量 size 判断，为空返回 true，非空返回 false

获取元素个数

int QSize(Queue* pq)
{
	assert(pq);
	#获取元素个数
	return pq->size;
}

传入队列，断言传入指针不为 NULL
pass

销毁队列

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

传入队列，断言传入指针不为 NULL
与销毁链表的流程大致相同，注意需初始化头尾指针和 size 变量

一份测试代码

void Test_Queue()
{
	Queue q;
	#初始化测试
	QueueInit(&q);
	#入队测试
	QNodePush(&q, 1);
	QNodePush(&q, 2);
	QNodePush(&q, 3);
	QNodePush(&q, 4);
	#出队测试
	QNodePop(&q);
	QNodePop(&q);
	#获取队头数据测试
	printf("%d\n", QueueFront(&q));
	#获取队尾数据测试
	printf("%d\n", QueueBack(&q));
	#判断是否为空测试
	printf("%d\n", QueueEmpty(&q));
	#获取元素个数测试
	printf("%d\n", QSize(&q));
	#销毁队列测试
	QueueDestroy(&q);
}

总结

链表实现队列的优缺点：

维度分析
时间复杂度所有操作均为 O(1)
空间复杂度O(N)，每个元素额外存储一个指针变量（64 位系统下 8 字节）
缓存命中率较差，节点在堆中分散分配，跳跃访问导致缓存未命中
扩容成本无需扩容，动态增长，无一次性复制开销
适用场景元素数量动态变化大、无法预估容量、频繁入队出队且对内存分配不敏感的场景

三、四种实现的全面对比

方向选择

我们换位思考，先看链表实现栈的场景：
如果用表头做栈底，表尾做栈顶，则每次返回栈顶数据都需遍历链表，操作的时间复杂度为O(N)。如果用表头做栈顶，表尾做栈底，则时间复杂度不变
再看数组实现队列的场景：
使用高下标位的方向作为队头，低下标位的方向作为队尾时，执行入队操作时需整体右移元素，时间复杂度为O(N)。使用高下标位的方向作为队尾，低下标位的方向作为队头时，执行出队操作时需整体左移元素，时间复杂度为O(N)。如果两种操作均不移动元素，在使用数组实现队列时会出现假溢出问题，导致浪费空间越来越多
由此，关于栈顶、栈底、队头、队尾方向的选择问题便有了大致的概念

对比表格

为了更清晰地看到 数组 vs 链表 在栈和队列上的差异，下表从多个维度做了详细对比

对比维度数组实现栈链表实现栈链表实现队列数组实现队列
底层结构连续内存数组单向链表（头插/头删）单向链表（头删/尾插）连续内存数组 + 头尾指针
核心操作入栈、出栈在数组末尾入栈、出栈在链表头部入队在尾部，出队在头部入队在尾部，出队在头部
最坏时间复杂度入栈扩容时 O(N)始终 O(1)始终 O(1)入队扩容时 O(N)，需要搬移元素 O(N)
空间占用容量可能大于实际元素数，浪费空间每个元素多一个指针，额外空间开销大每个元素多一个指针，额外空间开销大容量可能浪费，但无指针开销
缓存命中率极好（顺序访问）差（节点分散）差（节点分散）极好（顺序访问）
是否需要动态扩容需要，有复制成本不需要，动态分配节点不需要，动态分配节点需要，有复制成本
空栈/空队列判断top == 0head == NULLsize == 0front == rear
典型应用场景函数调用栈、表达式求值浏览器历史（可双向）消息队列、BFS 队列任务队列（但实际多用链表）

——数组天生适合栈，因为栈的操作只在一端进行，数组的末尾操作O(1)且缓存命中率高，扩容成本均摊后微乎其微。链表天生适合队列，因为队列要在两端操作，链表的头删尾插均为O(1)且无需搬移元素，动态增长无容量限制。

整体总结

通过本文，你不仅掌握了栈和队列的核心概念与操作，更重要的是，我们从底层存储视角剖析了数组与链表这两种实现方式的内在权衡：
➤数组的优势在于缓存命中率高和随机访问，但扩容和搬移元素是它的代价。因此数组适合操作集中于末尾(比如栈)的场景，而在队列中需要额外设计来避免搬移元素(循环队列)。
➤链表的优势在于动态伸缩和无需搬移元素，但代价是指针占用额外空间和缓存命中率低。链表适合两端操作频繁的队列，而在实现栈中并非最优解。

四、练习

推荐以下LeetCode题目
20. 有效的括号 & 链接：link.
225. 用队列实现栈 & 链接：link.
232. 用栈实现队列 & 链接：link.

⚛️EL PSY CONGROO，十分感谢你的阅读

本期不确定：
推荐的练习题是否充足，是否“高效”

图解数据结构之数组、链表、栈、队列
全栈开发者
10-17 889
一 数组 数组（Array）是一种很常见的数据结构。它是由相同类型的元素（element）的集合所组成，并且被分配一块连续的内存来存储（与链表对比）。利用元素的索引（index）可以计算出该元素对应的存储地址。它的特点是提供随机访问并且容量有限。 假如数组的长度为 n。 访问：O（1）//访问特定位置的元素 插入：O（n ）//最坏的情况发生在插入发生在数组的首部并需要移动所有元素时 删...
蓝桥杯Python赛道备赛——Day4：数据结构基础（链表、栈、队列、二叉树、堆、哈希表）
m0_72303604的博客
03-14 2365
本博客就蓝桥杯中所需的数据结构基础知识，结合示意图和示例代码对其定义及基本操作进行解释，包括：链表、栈、队列、二叉树、堆和哈希表。
【数据结构】栈和队列-----数据结构中的双生花
凤年徐的博客
07-16 2810
栈与队列：数据结构中的双生花 本文深入探讨了栈(Stack)这一基本数据结构，重点分析了其核心特性和实现方式。栈遵循后进先出(LIFO)原则，主要通过数组或链表两种方式实现。文章详细比较了两种实现的优劣，指出数组实现由于连续内存访问和O(1)操作复杂度更具优势。此外，还提供了完整的C语言动态栈实现代码，包含初始化、销毁、入栈、出栈等关键操作，并附有可视化示意图帮助理解栈的结构和工作原理。
线性数据结构的基本概念（数组，链表，栈，队列）
kiku1002149488的博客
08-21 2054
链表使用的不是连续的内存空间来存储链表的插入和删除操作的复杂度为 O(1)查询或者访问特定位置的节点的时候复杂度为 O(n)。链表相比于数组会占用更多的空间，因为链表中每个节点存放的还有指向其他节点的指针栈只允许栈顶（ top）进行加入数据（push）和移除数据（pop）。按照后进先出（LIFO, Last In First Out）的原理运作。栈常用一维数组或链表来实现，用数组实现的栈叫作顺序栈，用链表实现的栈叫作链式栈。队列（Queue）是先进先出 (FIFO）的线性表。
【数据结构】——栈和队列的数组vs链表，含实操源码（中缀表达式，括号匹配，循环队列实现）
weixin_61985100的博客
04-11 1429
详细介绍队列和栈，数组和链表的区别，包含源码。以及栈实现的括号匹配问题，中缀表达式，和队列的的循环队列设计。
数据结构----(数组,链表,栈,队列，树，哈希表)
m0_67466364的博客
03-26 1558
table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。队列（Queue）是先进先出（FIFO，first int first out）的线性表。当我们需要按照一定顺序来处理数据的时候，可以考虑使用队列这个数据结构。包含两个指针，一个prev指向前一个节点，一个next指向后一个节点。（LIFO，last in first out）的原理运作。有趣的理解（只是便于理解）
【数据结构入门】一文吃透线性数据结构：数组、链表、栈、队列、优先队列
Karl的博客
02-28 963
本文系统讲解了线性数据结构的基础概念与核心类型。数据结构是计算机科学的基础，而线性结构是最简单常用的一类，其特点是数据元素间存在一对一关系。文章重点介绍了数组和链表这两大基石：数组支持随机访问但插入删除效率低，链表则相反。还讲解了字符串作为字符数组的特性，以及线性表作为抽象逻辑结构的概念。在此基础上，详细阐述了两种特殊线性表——栈（后进先出）和队列（先进先出）的原理与应用场景。最后介绍了优先队列这一按优先级出队的重要结构。这些线性数据结构是构建更复杂结构的基础，理解它们的存储方式、优缺点对算法学习和工程开发
【数据结构】栈和队列
睿的博客
03-26 1156
你真的掌握队列和栈的知识吗？快来学学吧！
数据结构-线性数据结构-数组-链表-栈-队列
Java程序员的知识博客
02-08 1089
链表（LinkedList）虽然是一种线性表，但是并不会按线性的顺序存储数据，使用的不是连续的内存空间来存储数据。链表的插入和删除操作的复杂度为 O(1) ，只需要知道目标位置元素的上一个元素即可。但是，在查找一个节点或者访问特定位置的节点的时候复杂度为 O(n)。使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但链表不会节省空间，相比于数组会占用更多的空间，因为链表中每个节点存放的还有指向其他节点的指针。
栈与队列之队列入门攻略：从核心概念到链表实现
2502_93596214的博客
01-06 1148
本文为线性表系列栈与队列篇第二篇入门内容，聚焦队列这一受限线性表。通俗讲解队列“先进先出”的核心特性，对比数组与链表实现方式的优劣，选定单向链表为最优方案。通过工程化的头文件+源文件结构，完整实现队列的初始化、销毁、入队、出队等核心操作，详解队头队尾指针的边界处理，补充空队列、单节点队列等特殊场景的应对逻辑。
从硬件中断到分布式协程：全景解构高并发机制与 C / Golang 的巅峰对决
m0_70854309的博客
06-15 252
本文深入探讨了高并发技术在互联网后端与嵌入式系统中的不同实现形式。文章首先厘清了并发与并行的本质区别，指出高并发的核心在于资源复用最大化。随后分析了新能源汽车、物联网网关等典型高并发应用场景，并详细解构了硬件层（ADC/DMA）和软件层（无锁队列/协程）的高并发实现原理。通过对比C语言与Golang在高并发实现上的差异，揭示了前者在硬实时控制、后者在大规模分布式处理方面的优势。文章最终指出，技术选型应基于具体场景需求，硬实时控制选C语言，海量结构化数据处理选Golang。全文贯通底层硬件与上层软件，为工程师
手写 AI 检索重排序引擎：从零实现 Cross-Encoder 精排与 RAG 质量提升
picture_share的博客
06-17 475
我们的 Cross-Encoder 基于 BERT，在[CLS]位置后接一个线性分类头输出相关性分数。"""从零实现的 Cross-Encoder 重排序模型"""self,):# 加载预训练 Transformer 编码器# 分类头：[CLS] 向量 → 相关性分数hidden_size = self.config.hidden_size # BERT-base 是 768nn.GELU(),"""初始化分类头的权重"""self,"""
Python 优雅解析 Excel：从原生行列到强类型对象的三层数据结构演进
asdzx67的博客
06-15 315
对于数据结构固定、业务逻辑复杂的 Excel 场景，字典结构的弱类型特性会带来类型混乱、无代码提示、无法封装业务逻辑等问题。定义业务实体类，将每行 Excel 数据映射为实体对象，实现强类型约束、自动代码补全、自定义数据校验和业务方法封装。从「二维列表数字索引」到「字典语义取值」，再到「自定义对象强类型封装」，三层数据结构的迭代，本质是代码从「机器思维」向「业务思维」的升级。简单场景无需过度设计，通用场景优先字典列表，工程化复杂场景首选自定义实体对象。
哈夫曼树
Queenie_Charlie 的博客
06-13 280
实际上，哈夫曼算法的实现与实际问题所采用的存储结构有关。现假设用数组F来存储哈夫曼树，其中第i个数组元素F[i]是哈夫曼树中的一个结点，其地址为i，有3个域，Data域存放该结点的权值，lChild域和rChild域分别存放该结点左、右子树的根结点的地址（下标）。在以后每步构造一棵新二叉树时，都需要对森林中所有二叉树的根结点进行排序，因此可用数组a作为排序暂存空间，其中第i个数组元素a[i]是森林F中第i棵二叉树的根结点，有2个域，Data是根结点所对应的权值，Addr是根结点在F中的地址（下标）。
多线程编程（一）
m0_62591054的博客
06-16 199
编译时：需加上 -lpthread，链接上对应的线程支持库。
算法与数据结构---二叉搜索树(BST)
最新发布
MzKyle的博客
06-17 1281
二叉搜索树（BST）是一种基于二叉树的有序数据结构，核心特性是左子树节点值小于根节点，右子树节点值大于根节点。本文系统介绍了BST的核心概念与操作实现： 基本定义：BST通过"左小右大"的规则维护有序性，所有操作复杂度为O(h)，h为树高。平衡时h≈log₂n，退化为链表时h=n。 关键操作： 查找：根据值比较选择左右子树路径 插入：在适当位置创建新节点 删除：处理三种情况（无子节点、单子节点、双子节点），最复杂的是用中序前驱/后继替代被删节点 重要特性：中序遍历BST会得到有序序列，这是BST的核心性质。
Python 五大核心数据结构完全指南：列表(List)、字符串(String)、元组(Tuple)、集合(Set)、字典(Dictionary)
小赵的博客
06-15 299
本文系统梳理了 Python 五大核心数据结构——列表、字符串、元组、集合、字典，涵盖各自定义特点、索引切片规则及常用操作方法。列表有序可变，字符串不可变但支持索引，元组不可修改，集合无序去重，字典存储键值对。通过对比表格总结适用场景，助力读者稳固编程基础，提升数据处理能力。
数据结构之链表OJ题(下)
2503_92261635的博客
06-12 685
本文介绍了三个链表相关算法题解：1) 141题使用快慢指针判断链表是否有环；2) 142题在判断有环基础上找到环入口，通过计算两段链表长度差定位交点；3) LCR026题重排链表，先找到中点，逆置后半段，再交替插入前半段。三题均涉及快慢指针技巧，并综合运用了链表基本操作，展现了处理链表问题的典型思路。
从kubectl学Visitor模式：如何优雅处理多态数据结构的遍历
java_cj的专栏
06-15 280
kubectl的Visitor模式解析 本文通过配置同步工具开发中的实际问题，引出了Visitor设计模式的应用场景。该模式的核心思想是将数据结构与操作逻辑解耦，使新增操作无需修改原有代码。 在kubectl源码中，Visitor模式被巧妙用于处理多种数据源（文件/HTTP/Git等）： 统一接口：定义Visitor接口和Info数据结构，屏蔽底层差异 多态实现：FileVisitor处理文件，URLVisitor处理HTTP请求，统一委托给StreamVisitor解析 扩展性：新增数据源只需实现Visi
【C++】数据结构之图的基本概念
L_0907的博客
06-17 261
本文系统介绍了并查集和图两种重要数据结构。并查集部分详细阐述了其基本概念、逻辑结构（森林表示）与物理存储（数组实现），重点讲解了路径压缩和按秩合并两种优化策略，并通过省份数量、等式方程等LeetCode题目展示了实际应用。图结构部分明确定义按秩合并顶点、边、有向/无向图等核心概念，比较了邻接矩阵和邻接表两种存储方式的优劣，给出了完整的C++实现代码。全文通过理论讲解结合代码实践，为后续学习图的遍历、最小生成树等算法奠定了坚实基础。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值