栈和队列从入门到实战：核心概念、代码实现与高频面试题

最近有学弟问我：“栈和队列这章很简单吧，一个先进后出、一个先进先出，考试前背两个小时定义就行了吧？”类似的问题我一年能被问到很多次。栈和队列的概念确实不难，难的地方在于它们能解决的问题极其广泛——函数调用、浏览器后退、括号匹配、消息队列、线程池、树的遍历、图的搜索，底层全是它们在支撑。刚学程序设计的时候没感觉，等真正去写代码或者面试刷题，你会突然发现这两个结构几乎无处不在。

这篇内容我从三个层面展开：先用最直白的方式说清楚栈和队列的本质，再带手写一遍代码避开常见实现坑，最后把考试、求职和工程里最常遇到的场景和变种题过一遍。无论你是期末复习、准备实验报告，还是做面试冲刺，都能拿来直接用。

1. 栈和队列的本质：不是两种容器，是两种操作约定

1.1 线性表的一个分支，两种玩法

教科书里把栈和队列归为“操作受限的线性表”。线性表大家都熟悉，就是一组数据排成一条线，可以在任意位置插入、删除、查找。当给线性表加上限制，只允许在某一端操作元素，就出现了栈；只允许在一端插入、另一端删除，就出现了队列。

栈的特点是后进先出（Last In First Out，LIFO）。你可以想象成自助餐厅里摞盘子：新洗好的盘子总是放在最上面，取用的时候也必须先从最上面拿走。往里放叫入栈（push），往外拿叫出栈（pop），能操作的那一端叫栈顶。这也是为什么很多教材画图时，栈都是一根竖着的容器，元素从顶部进出。

队列的特点是先进先出（First In First Out，FIFO）。生活中的排队打饭、医院叫号，都是这个逻辑。先到的人先被服务，后来的排在队尾等待。在队列里，新增元素的操作叫入队（enqueue），发生在队尾；移除元素的操作叫出队（dequeue），发生在队头。

很多人初学时会陷入一个误区：把栈和队列当成两种“存储容器”去背。实际更准确的理解是——它们是在一组线性数据上约定了操作方式的抽象结构。同样一份数据，用不同的操作规则去组织，呈现出来的行为就是栈或队列。这个认知会直接影响你后续如何选择合适的结构。

1.2 限制操作的好处，比你想的多

既然线性表本身就能在任意位置操作，那为什么还要特意限制成只能在栈顶、队头、队尾操作？直接操作不是更自由吗？我最早学的时候也有这个疑问，后来在真实场景里才慢慢理解：自由是有代价的，限制反而带来确定性。

举个例子，函数调用时系统需要记录每个函数执行完之后的返回地址。函数 A 调用函数 B，B 的返回地址必须先记住；B 调用 C，C 的返回地址又记在 B 的上面。当 C 执行完，只能先回到 B，B 执行完再回到 A。这个顺序天然就是后进先出，只有用栈才能保证“最后一次调用最先返回”这个规则不会乱。

再比如打印任务。你在办公室给同一台打印机提交了多个文件，打印机不可能按提交顺序倒着来，那样先提交的人会等到崩溃。队列存在的意义，就是保证公平和有序，把无需确定顺序的请求排成一条可预期的通道。

我并不觉得“限制”是坏事。恰恰是因为栈和队列只暴露少数几个操作，理解的人更容易判断在什么场景下用它们，代码也会更可控。很多人学二叉树遍历时觉得递归难懂，本质就是对“调用栈”这个概念不够熟悉；很多人做消息队列架构时设计得不顺手，本质是没把“排队”的语义想透。

1.3 先把最容易混淆的几个概念理清

栈这章概念不多，但有一部分同学会在细节上栽跟头：

• 栈顶和栈底。栈底是固定的一端，栈顶是元素进出的一端。判断栈是否为空，看的是栈顶位置；遍历栈时往往也是从栈顶往栈底走。
• 队头与队尾。队头是删除元素的一端，也就是最早进来的位置；队尾是插入元素的位置。有些教材把队头写成 front，把队尾对应 rear。可别在写代码时把指针搞反。
• 出入顺序。栈的进出都在同一端，所以“后进”的反而“先出”；队列进和出是两端分隔的，所以“先进”的“先出”。
• 判断长度时，栈只需要看栈顶指针或存储元素数量；循环队列则要考虑取模，稍后我会详细展开。

还有一个容易忽略的知识点：给定入栈序列 1 到 n，可能的出栈序列并不是随便排列都行。n 个元素的合法出栈序列数量是卡特兰数，公式为 C(2n,n)/(n+1)。当你刷到“判断某序列是否可能是合法出栈序列”这种题时，背后就是这个问题。很多学校的数据结构实验或期末考试都爱在这里做文章。

2. 栈的代码实现：顺序栈扩容和链式栈边界要抠细

2.1 数组栈与链式栈怎么选

实现栈有两种经典方式：用数组实现（顺序栈）和用链表实现（链式栈）。两者各有特点，考试和面试常被问到，需要能说出差异和取舍。

实际工程中，动态数组实现的栈更常见。因为栈的操作只在尾部进行，数组尾部插入、删除都是 O(1)，而且连续内存对缓存更友好。课程实验里让你用链表再写一遍，主要目的不是让你在项目里用链式栈，而是通过手写节点、指针的指向关系，把链表基本功打牢。

2.2 用数组实现一个会自动扩容的栈

这里给一个用 Python 手写顺序栈的例子。很多教材直接用 C 语言固定数组，便于讲清“上溢”“下溢”概念，但真实代码里不可能一点余量都不留。我写的这版模拟了动态扩容，逻辑上更接近 Java 的 ArrayList、Python 的 list 这类动态数组：

python复制class Stack:
    def __init__(self, capacity=4):
        self.capacity = capacity
        self.data = [None] * capacity
        self.top = -1  # top 表示当前栈顶元素在数组中的下标

    def is_empty(self):
        return self.top == -1

    def is_full(self):
        return self.top == self.capacity - 1

    def push(self, value):
        if self.is_full():
            self._resize(self.capacity * 2)
        self.top += 1
        self.data[self.top] = value

    def pop(self):
        if self.is_empty():
            raise IndexError("pop from empty stack")
        value = self.data[self.top]
        self.data[self.top] = None  # 释放引用，方便调试观察
        self.top -= 1
        return value

    def peek(self):
        if self.is_empty():
            raise IndexError("peek from empty stack")
        return self.data[self.top]

    def _resize(self, new_capacity):
        new_data = [None] * new_capacity
        for i in range(self.top + 1):
            new_data[i] = self.data[i]
        self.data = new_data
        self.capacity = new_capacity

    def __len__(self):
        return self.top + 1

这段代码有几个细节要特别说明。

第一，初始化把 top 设为 -1，表示数组为空。当插入第一个元素时，top 先自增为 0，再从 data[0] 位置放入数据。如果初始化 top = 0，表示下一个空位在 0 号下标，那判空的逻辑和存取位置都完全不一样。写代码前先确认你用的是哪种约定，不要中途混用。

第二，扩容的时机一定是在 push 开头处理。先检查栈是否已满，满了就扩容，然后再做 top 自增和赋值。反过来写容易出现数组越界，哪怕 Python 的 list 会自动扩容，一旦改写成 C 语言版本，这就是经典的缓冲区溢出问题。

第三，pop 操作要先取出当前栈顶元素，再把 top 减 1。很多人写反成“先移动指针再取值”，结果拿到了被覆盖前的位置甚至越界内存。动手写实验报告时，可以故意在纸上模拟一次越界，体会下这条时序的重要性。

2.3 链式栈的操作顺序真的别写反

链式栈在 C 语言教材中很常见，核心思路是把新节点插入链表头部，然后让头指针指向新节点；删除时删除头节点。如果理解不到位，很容易写成“尾插法”，那复杂度会退化成 O(n)。

用 C 语言定义节点一般是这样：

c复制typedef struct Node {
    int data;
    struct Node *next;
} Node;

入栈操作的核心只需要两步：新节点的 next 指向当前栈顶节点，然后把栈顶指针更新为新节点。

c复制void push(Node **top, int value) {
    Node *new_node = (Node *)malloc(sizeof(Node));
    new_node->data = value;
    new_node->next = *top;
    *top = new_node;
}

出栈时要注意，必须先保存当前栈顶节点的值，再更新栈顶指针到下一个节点，最后释放原栈顶节点。

c复制int pop(Node **top) {
    if (*top == NULL) {
        printf("stack underflow\n");
        exit(1);
    }
    Node *tmp = *top;
    int value = tmp->data;
    *top = tmp->next;
    free(tmp);
    return value;
}

只要你把链表画出来，再对比代码，会发现链式栈和“在链表头部做增删”是同一回事。理解了这一步，后面学链式队列、链式二叉树时，指针操作会顺畅很多。

2.4 栈操作三个常见事故现场

从我自己带人和批实验报告的经验看，顺序栈方面常见的错误集中在下面几处：

• 判空、判满条件写反。比如 top == capacity - 1 才是满的，但一些人写成 top == capacity，结果永远判不满，数据越界了才发现。
• push 和 pop 的指针移动顺序搞错。入栈先移动指针后赋值没问题，但出栈必须先取值后移动指针。顺序一乱，取到的就是错误数据。
• 扩容时复制数据的范围用错。有些代码用整个 capacity 复制，实际上只需要复制从 0 到 top 的有效部分，多复制那些空位没意义，还可能把未定义内容带进新数组中。

链式栈方面，最典型的是忘掉对空栈做保护。在 C 语言里访问空指针的 next 会直接段错误，很多同学 debug 很久才找到原因。写任何栈操作前，先把“空栈时调用 pop/peek 会怎样”这个边界想清楚。

3. 队列的经典坑：从顺序队列假溢出到循环队列

3.1 为什么最简单的数组队列不能直接用

如果只是拿数组记录队列，并且让 front 指向队头、rear 指向队尾的下一个位置，入队是 rear 后移，出队是 front 后移。看着没毛病，但跑几次就会发现：即使队头前面还有大片空闲位置，当 rear 走到数组末尾时，新元素也入不了队。

举个例子。一个长度 5 的数组，先入队三个元素，再出队两个，此时 front 指向下标 2，rear 指向下标 3。数组下标 0、1 其实空了，但当 rear 到达下标 4 时，如果继续入队，rear 再加就超出数组边界了。这就是“假溢出”——数组明明还有空位，却无法使用。若每次都把元素往前搬移，入队退化成 O(n)，这不可接受。

解决思路就是循环队列。把数组在逻辑上首尾相接，当 rear 走到数组末尾时，通过取模让它回到开头继续使用。换句话说，队列中每个位置的下一跳被重新定义为：(当前下标 + 1) % capacity。

如果只看文字理解不了，建议拿一张纸条，把数组画成一圈，亲自动手模拟一次入队、出队，会比盯着公式有效得多。

3.2 手写一个循环队列，条理一次理顺

循环队列最绕的地方是：如何区分队空和队满。如果 front == rear，可以代表空队列；但如果满的时候也让 rear 走到了 front 的位置，就会出现歧义。常用的解决办法是牺牲一个存储单元：当队列元素个数达到 capacity - 1 时，就认为队满，rear 永远不会追上 front。

对应 Python 代码可以这样写：

python复制class CircularQueue:
    def __init__(self, capacity):
        # 内部数组多申请一格，用来区分队空和队满
        self.capacity = capacity + 1
        self.data = [None] * self.capacity
        self.front = 0  # 指向队头元素
        self.rear = 0   # 指向队尾元素的下一个位置

    def is_empty(self):
        return self.front == self.rear

    def is_full(self):
        return (self.rear + 1) % self.capacity == self.front

    def size(self):
        return (self.rear - self.front + self.capacity) % self.capacity

    def enqueue(self, value):
        if self.is_full():
            raise OverflowError("queue is full")
        self.data[self.rear] = value
        self.rear = (self.rear + 1) % self.capacity

    def dequeue(self):
        if self.is_empty():
            raise IndexError("dequeue from empty queue")
        value = self.data[self.front]
        self.front = (self.front + 1) % self.capacity
        return value

    def peek(self):
        if self.is_empty():
            raise IndexError("peek from empty queue")
        return self.data[self.front]

在构造方法中，用户传入的期望容量是 4，内部数组却申请成 5，多出的那一个空格子专门用来区分状态。调用方的视角是“队列最多能放 4 个元素”，内部实现却要牺牲一格，这是很多实验报告里没写明白的关键点。

长度公式 (rear - front + capacity) % capacity 也很好验证。比如容量 5 的数组，front = 3，rear = 1，说明元素占了下标 3、4、0 三个位置，size = (1 - 3 + 5) % 5 = 3，正好是 3。

3.3 生产场景里的队列选择：有界、无界并不是随手写的

循环队列看起来是课程里的概念，实际上很多底层组件就是类似实现。Java 的 ArrayDeque 底层就用循环数组，ArrayBlockingQueue 作为有界阻塞队列，也基于循环数组实现。LinkedBlockingQueue 则默认使用链表实现，支持无界或指定容量。你可以认为：凡是需要固定容量、高性能、避免频繁创建节点的场景，都会优先考虑环形缓冲区思路。

平时关注后端技术栈的话，你大概率听到过“阻塞队列”这个词。线程池里的任务队列就是典型应用。如果生产者提交任务的速度超过消费者的处理速度，积压任务会被放到队列中。选无界队列可能让内存持续涨高，最终 OOM；选有界队列虽然会触发拒绝策略，但至少不会让整个应用崩溃。这些看似是工程经验，根子上还是对队列容量和控制条件的理解。

做业务开发时还会遇到消息队列，比如处理订单、日志、通知等场景。消息队列的底层不一定是上面这套循环数组，但“先进先出、按序消费”的语义仍然是许多系统的基石。理解消息顺序为什么重要，其实就是理解队列为什么先进先出。

3.4 队列实现中的边界细节速查

不同教材对循环队列的定义，可能把 rear 指向最后一个元素，也可能指向最后一个元素的下一个位置。写法不同，判断队空队满的公式也不一样，容易造成困惑。

我的建议是：学习时只死磕一种约定，把它彻底写熟，考试时注意看清题目文字描述。不要每换一本教材就换一套思路，那样只会越学越乱。

队列最容易出的错包括：出队后忘记让 front 前进、入队前忘记判满、使用取模时负数处理不正确。Python 的取模对负数结果仍然是非负，但 C 语言和 Java 里 -1 % n 可能得到不符合预期的负值，所以公式中先加 capacity 再取模会稳妥很多。

4. 栈和队列的真实应用：从函数调用到消息队列

4.1 栈的第一现场：函数调用链与栈回溯

每次调用函数时，系统会把函数参数、局部变量、返回地址打包成一帧，压入系统维护的调用栈；函数执行完返回时，再从栈顶弹掉当前帧。递归程序执行得越来越深，调用栈就越来越高；如果递归没有出口或深度太大，系统栈空间被耗尽就会栈溢出。这也是刷算法题时，遇到深层递归要考虑改成显式栈或迭代的原因。

“栈回溯”这个词在故障排查中很常见。程序崩溃时，调试工具会把当前调用栈从上到下打印出来，告诉你这个异常是从哪个函数一路传到哪个函数。这条路径本身就是一个栈结构：越新的调用越靠近栈顶，被打印在最前面。

我见过有些初学者觉得函数调用栈离自己很远。其实只要写过 C 语言断点调试，在 IDE 的“调用堆栈”窗口里看过一次，就能真实感受到那一层层的函数调用关系。理解了这一点，递归、DFS、回溯算法这些内容，就会从“玄学”变成“顺着栈走一遍”。

4.2 用栈解决括号匹配与表达式求值

做数据结构实验时，栈最经典的案例就是括号匹配。处理一个只包含括号的字符串，遇到左括号就压栈，遇到右括号就检查栈顶是否是对应类型的左括号。匹配就弹出，不匹配则直接认为非法；字符串扫描结束后，发现栈里还有未匹配的左括号也说明非法。

表达式求值同样非常依赖栈。以中缀表达式 3 + 4 * 2 为例，如果直接从左到右计算会出错，因为乘法的优先级更高。你可以把表达式转成后缀表达式 3 4 2 * +，再用栈求值：遇到数字就入栈，遇到运算符就从栈里弹出两个操作数，计算后把结果压回栈。最终栈里留下的唯一数字，就是整个表达式的结果。

这套机制后来被扩展成 Dijkstra 双栈算法。它的思路是用两个栈分别保存运算符和操作数，遇到左括号就把运算符压栈，遇到右括号就弹出运算符和操作数计算，再压回操作数栈。很多计算机组成原理教材在讲表达式求值的硬件实现时，也会用到这套模型。因此栈不只是数组操作的练习题，它紧紧连着编译原理、汇编语言和硬件的执行流程。

4.3 队列的第一现场：消息队列、线程池和BFS

队列在编程里最直观的应用是广度优先搜索（BFS）。比如在一个迷宫矩阵里找从起点到终点的最短路径，先让起点入队，然后反复取出队头节点，把它的相邻节点入队，直到队列为空或找到终点。因为这个过程是按层展开的，先入队的第一层节点必然会被先处理，所以天然要用队列而不是栈。

在系统设计层面，队列更多用来削峰填谷和解耦。举个例子，电商大促瞬间涌来大量下单请求，后端服务如果同步处理每一个请求，很容易被峰值流量打垮。常见的做法是把请求写入消息队列，后端消费者按自己能承受的速度慢慢拉取处理。这样哪怕瞬时流量很大，系统也只是往队列里多存了一些消息，不会直接崩溃。

有些同学会问，消费端从队列拉数据，那“重复消费”怎么处理？这取决于消息系统的投递语义。很多消息队列为保证不丢消息，会采用至少一次投递，也就是说同一条消息可能被消费多次。消费方必须在处理逻辑上做幂等，比如记录处理过的消息 ID，才能避免重复下单、重复入账。这些工程经验和单纯的数据结构题距离有点远，但底层的顺序消费思想依然是队列那套理论。

在多线程环境里，阻塞队列也是生产者 - 消费者模型的核心组件。生产者线程把任务放进队列，消费者线程从队列中取出任务处理；当队列为空时消费者阻塞等待，当队列有界且已满时生产者阻塞等待。理解了这个模型，再看线程池的排队策略，会清楚很多。

如果你未来走全栈方向，会在浏览器实现里看到页面访问历史栈，在任务调度里看到请求队列，在状态管理模型里看到事件队列。这些场景看起来五花八门，本质都是栈和队列的应用。换句话说，把这两个基础结构学扎实，就是在给后面所有系统设计能力打地基。

4.4 顺带分清双端队列和优先队列

学完普通队列，很多人会被双端队列（Deque）和优先队列（PriorityQueue）这两个名字带偏。

双端队列允许在队头和队尾两端都进行插入与删除操作，所以它既能当栈用，也能当普通队列用，还能实现滑动窗口等更灵活的逻辑。Java 里的 ArrayDeque 就是双端队列的典型实现。

优先队列听着叫队列，实际弹出的顺序并不完全按入队时间，而是按元素的优先级大小来定。底层通常是堆，而不是普通队列。很多人误以为它还是先进先出，结果在面试题里答非所问。

建议把三者放在一起分辨：普通队列只允许一端入、另一端出；双端队列两端都能进出；优先队列则要按优先级决定出队顺序。能用一句话说清它们的差异，说明你真的理解了。

5. 考试和面试都爱考的栈队列变种题

5.1 合法出栈序列如何判断

给定入栈序列是 1 到 n，再给你一个出栈序列，让你判断它是不是可能的合法出栈序列。这是栈的必考题型。

判断思路并不复杂。用一个栈模拟入栈过程，同时维护一个下标指向出栈序列当前待匹配的位置。循环将每个元素入栈，入栈后不断检查栈顶是否等于出栈序列中当前指向的元素，如果相等就出栈，同时下标后移。最后如果出栈序列所有元素都匹配完，就说明合法。

python复制def is_valid_pop_sequence(pop_seq):
    n = len(pop_seq)
    stack = []
    j = 0
    for value in range(1, n + 1):
        stack.append(value)
        while stack and stack[-1] == pop_seq[j]:
            stack.pop()
            j += 1
    return j == n

举例来说，入栈序列 1, 2, 3, 4, 5，出栈序列 4, 5, 3, 2, 1 是合法的；而出栈序列 4, 3, 5, 1, 2 则非法，因为 4 出栈时 1、2、3 已经压在栈里，而 1、2 的相对顺序决定了 2 不可能在 1 之前出栈。这类题目背结论没用，手写一次模拟过程就记住了。

5.2 两个栈实现队列，两个队列实现栈

“用两个栈实现一个队列”是高频手写题。核心思想是：入队时直接往栈 s1 中压；出队时先检查栈 s2 是否为空，如果为空，就把 s1 中所有元素依次弹出并压入 s2，再从 s2 弹出。这个操作能把 s1 里的元素反序成正确顺序，相当于把“后进先出”调整成“先进先出”。

不过要注意，每次只有在 s2 为空时才需要倒腾，所以虽然单个出队操作偶尔是 O(n)，均摊下来仍然是 O(1)。这是面试官很喜欢追问的复杂度问题。

反过来“用两个队列实现一个栈”同样有经典做法。入栈时把新元素放入非空队列；出栈时把该队列里除队尾外的所有元素依次移入另一个队列，剩下的那个元素就是要弹出的栈顶元素。简单理解就是：队列只能队头出队，所以要反复“腾挪”，把最后一个元素暴露到队头再删除。

5.3 最小栈、单调栈、单调队列，怎么衔接到下一阶段

入门后，栈和队列可以延伸出很多高频面试题。

最小栈要求在 O(1) 时间内获取栈内最小值。常规做法是维护两个栈：数据栈正常存元素，辅助栈同步存当前的最小值。入栈时，如果新元素比辅助栈栈顶还小，就压入新元素，否则重复压入栈顶最小值；出栈时两个栈一起弹。还要注意遇到相等元素，只有严格使用 <= 或 >= 处理，才能保证辅助栈的同步逻辑没有漏洞。

单调栈常用于解决“下一个更大元素”“柱状图中最大矩形”“每日温度”等问题。它维护一个栈内元素单调递增或单调递减的序列，利用栈顶快速判断元素的顺序关系。

单调队列则常用来解决滑动窗口最大值问题。比如说，给定一个数组和一个固定大小的窗口，窗口每次向右移动一格，要求在每次移动后都能快速输出窗口内最大值。这种场景用堆也可以做，但用双端队列维护一个递减队列，均摊 O(1) 且有更好的常数性能。

对正在准备数据结构期末的同学来说，理解到能看懂思路即可；但如果你打算准备面试，建议每一类都找 3 到 5 道题实际刷一遍。只有动手写，才能理解单调栈里的“什么时候弹出”到底代表什么含义。

5.4 期末复习与面试的轻量路线

期末复习或面试前，不需要把教材从头翻到尾，按下面这条路线走会比较高效。

第一关是概念与手写结构。能独立写出顺序栈、链式栈、循环队列、链式队列，并准确说出判空、判满条件与存取顺序。很多学校的实验报告，考查点就在这些基础结构上。

第二关是能识别应用场景。遇到逆序输出、括号匹配、函数调用、表达式求值，优先想到栈；遇到排队、BFS、任务调度、异步削峰，优先想到队列。

第三关是能解决变形题。包括合法出栈序列、双栈模拟队列、两个队列模拟栈、最小栈、循环队列中如何实现 O(1) 取队首，这些面试中反复出现。

资源方面，严蔚敏的《数据结构（C语言版）》虽然实现代码相对早期，但概念讲得清晰，很多学校的课程都离不开它；王卓老师或王道系列整理出来的课件与讲义，适合复习时快速抓重点。看这些资料时不必逐行抄代码，关键是跟着过程画图，理解每一步的状态变化。用另一种语言把教材里的结构再写一遍，往往比反复看书更有用。

6. 最后分享点带新人时积累的心得

6.1 先画状态，再写代码

栈和队列看似代码都很短，但大多数人第一次没写对，问题往往出在边界状态上。我习惯让身边的人先在草稿纸上画一个三列小表格：操作名称、操作前状态、操作后状态。比如入栈前 top 是多少，入栈后数组哪个位置被占用，出栈后 top 应该指到哪里。只要自己能画出完整状态，代码基本不会错。

这招对循环队列尤其有效。你可以把数组画成一个环形车道，标出 front 和 rear 的位置，一格一格地模拟入队出队，直到亲眼看到“空一格”是怎么区分队列空与满的。之后再看公式，就再也不会觉得是死记硬背了。

6.2 给自己留一道五分钟自测

最后给你留一个很简单的自测：在不看任何资料的情况下，用你熟悉的语言写出一个循环队列，要求支持入队、出队、判空、判满、取队首、获取当前长度。写完后试着把容量设为 1，再设容量为 2，测试各种边界情况。

如果五分钟内能完整写对，说明循环队列方面的理解已经过关。如果会卡壳，说明还需要回看 3.2 节这部分的代码和图示。栈和队列本来就是内容很基础但应用极广的结构，花一个晚上把它们彻底吃透，后面学习二叉树、图、排序算法时你会明显感觉轻松很多。