用C语言从零实现栈、队列与串：核心原理与工程应用

1. 先把话说清楚：为什么这三个老东西值得再写一遍

很多人一听到栈、队列、串，第一反应是“这不是大二《数据结构》期末考试的重点吗”，然后脑子里浮现的可能是应付作业时拿链表把代码凑出来的痛苦回忆。但如果你工作了三五年再回头看，就会发现学校里教的那点东西，其实全是工程里的地基。

栈是什么？函数调用、递归、表达式求值、浏览器的后退按钮，全是栈。队列是什么？线程池、生产者消费者、异步消息、打印任务排队，全是队列。串是什么？文本搜索引擎的关键字匹配、代码编辑器的高亮、大数据里的日志过滤，全靠串匹配算法撑腰。你要是说你写代码从来不用这些，那大概不是用不到，而是用的时候没意识到自己在用。

我今天的主题非常明确：用C语言从零实现栈、队列、串这三个基础结构。为什么要用C？因为C语言没有现成的容器库，没有STL vector，没有java.util.LinkedList，一切存储和内存都得自己管。这一管，存储结构、指针操作、边界条件这些基本功就全被逼出来了。用C敲过一遍数据结构的人，再看别的语言里的那些封装容器，基本就是降维理解。

这篇文章适合谁？计算机专业的大一大二学生、准备考研刷专业课的人、工作中基础不扎实想回头补课的开发者。我能保证的是：不搞花活，不炫技，每一个实现都能直接抄下来跑，每一步背后为什么这么写，我尽量讲透。学完你能获得什么？三种基础数据结构的完整代码和理解框架，以及它们在后端、嵌入式、算法题里的实际根脉。

2. 整体设计思路：先想存储，再写代码

2.1 顺序存储还是链式存储，先想清楚

数据结构里，逻辑结构是“栈、队列、串”这些东西，物理存储只有两种：连续数组和离散节点。写代码之前，这个选择必须先落地。

拿栈来说，考卷上常见的问法是“栈的进出方式是什么”，后进先出（LIFO）。这个逻辑结构不论底下的存储是顺序还是链式，它都得满足后进先出。那两种存储用哪个？如果空间大小一开始就能估算，栈的最大深度不会超过某个阈值，直接用顺序栈，代码短、访问快、内存没有额外的指针开销。反过来，如果栈的容量不可预知，有可能暴涨，链栈就更合适，因为内存按需分配，不用一开始就赌一个上限。

队列同理。循环队列是一个很典型的用“数组+头尾指针”模拟环状空间的设计，但它有一个天生的问题是“假溢出”怎么解决、队列满和队列空如何区分。链式队列就不用操心容量上限和假溢出，有节点就往后挂，但代价是每次操作要处理malloc和free。

我的实现思路是这样：栈我给顺序版，这是绝大多数场景里的默认选择；队列我给循环顺序版主实现，同时给出链式队列的完整实现，因为阻塞队列、消息队列这些工业场景里链表版的变种才是真正的主角；链式表示后文中也会涉及。串我只介绍堆存储版本，也就是通过malloc动态托管字符串空间，避免提前锁死最大长度。

一句话总结我的选型原则：如果在容量可预估、操作频繁的场景，顺序存储占优；如果容量不确定、结构需要频繁伸缩，链式存储占优。

2.3 宏定义和头文件能省多少事，就省多少事

我刚自学那会儿，写数据结构特别喜欢把所有函数都写在一个main.c文件里，跑通了就万事大吉。后来工作后看同事的工程结构才发现，一个结构一块头文件一块源文件是基本功。写基础数据结构，代码量不大，但模块划分的习惯从这时候就得养好。

栈的模块我会分成SqStack.h和SqStack.c。头文件里放结构定义、函数声明、宏定义，比如初始容量、扩容步长、状态码。源文件里放函数实体。字符串相关我会专门写一个字符串头文件，把动态字符串的实现和模式匹配算法拆开，这样将来换算法只动一个文件，测试代码完全不用改。这套设计在企业工程里极其重要，因为底层实现大概率要频繁调优，接口层保持稳定才能让别人不跟着一起返工。

顺序栈的设计上，我采用C语言里比较常见的“结构体包数组”方案，动态声明一块堆内存。这里和静态数组的栈最大的区别是，容量可以随数据量变化扩展，不会出现“栈满了就丢数据”的硬伤。串也采用类似思路，动态堆内存存储，长度用一个int类型来记录，这是为了后面实现KMP等匹配算法更方便，C语言里的char[]没有长度信息，常让你进退两难。

3. 第一站：栈的完整实现与常见陷阱

3.1 栈的结构和核心判断条件

先给顺序栈的结构体定义：

c复制#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define INIT_STACK_SIZE 16
#define STACK_INCREMENT 8

typedef struct {
    int *data;
    int top;       // 栈顶指针，始终指向栈顶元素的位置
    int capacity;  // 当前分配的数组容量
} SqStack;

很多初学者搞混的是栈顶指针的语义。不同的教科书、不同的人写的代码，top值有的指向栈顶元素，有的指向栈顶元素的下一个空位。这个不统一在考试里经常出错。我的主张是一开始就统一：top指向当前栈顶元素的位置，空栈时top = -1。

为什么不写成top = 0初始化，然后压栈后自增？那样空栈和“已有一个元素”之间容易出边界混乱。只要统一了top = -1，压栈时先top++再赋值，弹栈时先取值再把top--，这比任何口头背诵都好用。栈空判断是top == -1，栈满判断是top == capacity - 1。这两个条件和top的语义是一一对应的，码代码之前把这四行逻辑先想明白，后面就不会出低级错误。

3.2 压栈、弹栈与扩容

压栈操作除了常见的赋值和自增外，一个关键点是扩容检查。顺序栈用数组存，数组是连续的，一旦容量满了，要么扩展空间，要么宣告失败。无脑返回false的版本在课设里能过关，但工程里几乎不允许这种“存不下就拉倒”的态度。我给出扩容处理：

c复制bool Push(SqStack *s, int value) {
    if (s->top >= s->capacity - 1) {
        int newCap = s->capacity + STACK_INCREMENT;
        int *newData = (int *)realloc(s->data, newCap * sizeof(int));
        if (newData == NULL) {
            return false;
        }
        s->data = newData;
        s->capacity = newCap;
    }
    s->data[++(s->top)] = value;
    return true;
}

很多C语言新手谈realloc色变，其实realloc并没有那么可怕，只要记住两条铁律：第一，它的返回值必须重新赋值给原指针，不能以为原指针还像malloc那样有效；第二，一旦返回NULL，说明扩容失败，但原内存块依旧有效，不能被覆盖成NULL导致内存泄漏。你看我的代码里先用newData接收返回值，它不为空才覆写s->data，这就是比较安全的realloc姿势。

弹栈也容易有操作误区。有人很在乎弹栈后要不要把data[top]清零，觉得不清零就是残留数据。我的态度是：如果是int指针，清零与否都不影响逻辑。但如果是存了指针的栈——比如后面讲到的串匹配里的回溯信息栈——你在弹掉一个资源后还留有悬空指针，那就是引用计数和内存释放的大坑了。顺序栈清不清除数据取决于你栈里存的对象是否带资源，不要一概而论。

完整弹栈实现：

c复制bool Pop(SqStack *s, int *out) {
    if (s->top == -1) {
        return false;
    }
    *out = s->data[s->top];
    s->top--;
    return true;
}

int *out是C语言的常规出参写法，避免用返回值同时承载“是否成功”和“弹出的值”两个信息。如果只返回一个值，一旦返回-1，你怎么知道是栈空了还是真的弹出了-1？所以C语言工程里，凡是可能失败的函数，都用返回值表示成功与否，用指针参数把“带出去的数据”传递出来。这也是我特别想强调的一个设计习惯。

3.3 链栈实现：怎么让压栈和单链表头插法合二为一

如果数据量预判不了，顺序栈反复扩容虽然能用，但内存碎片和频繁申请也让人头疼。链栈是另一条路。它的核心思路是用单链表的头节点作为栈顶，压栈就是头插，弹栈就是删头。

结构体定义不需要额外的头节点，直接用节点指针作为栈顶：

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

typedef struct {
    StackNode *top;
    int size;
} LinkedStack;

压栈实现非常短：

c复制bool LPush(LinkedStack *s, int val) {
    StackNode *node = (StackNode *)malloc(sizeof(StackNode));
    if (node == NULL) return false;
    node->data = val;
    node->next = s->top;
    s->top = node;
    s->size++;
    return true;
}

弹栈则是把当前top节点取出来，然后top = top->next，最后释放旧节点。链栈的边界条件好判断到几乎不用思考：top == NULL就是空栈。这比顺序栈复杂吗？其实不复杂。真正让你抓狂的是漏了free，导致内存一点点涨上去。而且链栈每个节点有next指针，空间开销比顺序栈大约高30%，如果数据量巨大，这个额外开销值得纳入选型考虑。

3.4 栈的经典应用：括号匹配和表达式求值

代码写完不练等于白写。栈在实际中干什么用，很多人没有体感。最简单的例子是括号匹配。一个字符串里有(和)，还有[和]，如何判断是否合法？只用计数器是行不通的，因为([)]这种交叉嵌套情况下每个计数都对，但实际不合法。括号的闭合顺序满足后进先出：最后遇到的左括号必须最先被匹配。因此遇到左括号就入栈，遇到右括号就弹栈检查匹配，空了则说明右括号多了，最后栈非空则说明左括号多了。

另一个经典应用是逆波兰表达式求值。从头扫描表达式，遇到数字就压栈，遇到运算符就弹两个数字计算，算完把结果重新压栈。表达式求值是栈最本质的场景，2 3 1 * + 9 -求值过程中，人无法一眼看出优先级交错，但栈能消解所有顺序带来的复杂性，你只要盯着栈顶两个值即可。

这些题目刷懂以后再看后续栈的变种——比如单调栈求最大矩形、用双栈实现浏览器的前进后退——思路迁移就很自然了。说白了，栈在工程系统里最常见的角色就是“保存现场”，界面上叫“历史记录”，编译器里叫“调用栈”，游戏里叫“Undo栈”，本质全都一样。

4. 第二站：队列的实现与循环数组的边界战争

4.1 链式队列和循环队列的结构

队列的逻辑特征是先进先出（FIFO），相比栈的“一头操作”，队列需要一头进、另一头出。

先看链式队列的结构体。因为要“一头进另一头出”，所以光有一个头指针还不够，必须维护队头和队尾两个指针，否则出队时需要从队头走O(n)找到倒数第二个元素才能断链，丑且慢。

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

typedef struct {
    QNode *front;
    QNode *rear;
    int size;
} LinkedQueue;

链式队列的入队操作就是把新节点挂在rear->next上，同时让rear向前移动。出队操作稍微需要留个心眼：如果队里只有一个节点，出队后front和rear都要变成NULL，这一行漏写的话，rear会指向一个已经被free的内存，下一次入队就成了悬空指针操作。C语言的指针操作就是这样，忘了一个置空，问题不一定当时报出来，而会在某个远方出崩。

相比之下，循环队列用数组实现，入队出队都不用malloc/free，效率高且内存局部性好。它的结构体一般是：

c复制typedef struct {
    int *data;
    int front;
    int rear;
    int capacity;
} CircularQueue;

注意我这里的实现牺牲一个数组元素作为“满”与“空”的判断界线。初始时front = 0、rear = 0，插入时rear = (rear + 1) % capacity，删除时front = (front + 1) % capacity。于是队列空条件是front == rear，队列满条件是(rear + 1) % capacity == front。

4.2 循环队列初始化和入队出队

初始化时分配capacity大小的数组，但实际能用的只有capacity - 1格，这是上面那个方案的代价。如果你想全部利用空间，也可以引入size字段记录现有元素个数，入队时size++，出队时size--，判断条件改为size == 0和size == capacity。这种方案更直观，内存零浪费，就是在频繁出入队时多维护一个size，也没什么成本。我给出的以牺牲一格为代价的代码更具教学性，但工程实现里我倾向于用带size计数器的版本。

入队逻辑：

c复制bool EnQueue(CircularQueue *q, int value) {
    if ((q->rear + 1) % q->capacity == q->front) {
        return false; // 队满
    }
    q->data[q->rear] = value;
    q->rear = (q->rear + 1) % q->capacity;
    return true;
}

出队逻辑：

c复制bool DeQueue(CircularQueue *q, int *out) {
    if (q->front == q->rear) {
        return false; // 队空
    }
    *out = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    return true;
}

写循环队列必须时刻记住取模运算。front和rear在数组末端时，加1后并非自然回到0，而是(index + 1) % capacity。凡是把这点漏掉的人，多半会在“队列刚满时”产生越界，或者在“队列元素少于容量但rear已到末尾”时误判队满。我见过很多人在这个位置上浪费了一晚上的时间，各种打印中间状态，最后发现就是取模写成了自增。

4.3 线程池的阻塞队列为什么是队列的常见变种

有热词提到“线程池的阻塞队列选择”、“Java中的延时队列”、“消息队列重复消费问题”，这些真实的技术议题其实都建立在队列之上。

线程池的任务队列本质上就是一个队列，生产者向里面提交任务，消费者从里面取任务执行。队列的先进先出保证了任务的有序性。但普通队列有一个问题：当队列为空时，消费者如果不断轮询取出操作，CPU空转浪费资源，所以要把它升级成阻塞队列——队列为空时消费者线程被挂起，队列有数据时被唤醒。C语言里用pthread_cond_wait + pthread_cond_signal搭配互斥锁即可实现；Java里的ArrayBlockingQueue和LinkedBlockingQueue就是这种思路的标准成品。

延时队列的逻辑是队列元素都有到期时间，只有到期后才能出队。严格来说它已经不那么“队列”了，因为出队顺序是按照时间排序而不是按照入队顺序，更像一个优先队列变种。但它在消息调度里的角色定位还是“队列”。

消息队列重复消费问题则和数据结构无关，是分布式系统里“至少一次投递”语义下的去重问题，需要幂等设计。这个展开又是一篇文章，这里想表达的核心是人得先学会队列本身，才谈得上去理解这些中间件封装背后到底处理了哪些麻烦事。

4.4 队列的实际应用和大数据方向扩展

队列在开发里的典型场景非常多：打印调度、Windows消息循环、局域网数据包缓存、广度优先搜索（BFS）、CPU任务调度、Redis的发布订阅底层缓冲、Arduino里处理串口到达的数据包缓存，全都有队列的身影。只要存在“一端负责生产、另一端负责消费、希望两边不互相拖慢”的场景，队列几乎就是必然方案。

拿实现广度优先搜索举例：从起点出发，按层遍历图或树上的节点。先访问起点，把它的相邻节点全部入队，然后循环出队一个节点，把它未被访问的邻居节点再入队。因为队列的FIFO纪律，所有离起点距离为1的节点先于距离2的节点被访问。这与栈的“深度优先”正好两级分化。

我现在在项目里碰到高频数据缓冲、异步IO任务抽取，第一反应依然是队列。只要知道数据流方向上谁是Producer谁是Consumer，队列的参数就好定了。消息中间件Kafka、RabbitMQ也全都是这类思想在分布式的放大版，它们解决的是跨进程、跨服务器的队列管理问题。

5. 第三站：串的操作与KMP算法的三个关键点

5.1 C语言处理串的痛点

上一个结构的代码，用到动态扩容和指针，难度已经上来了。串这一层，表面上是字符操作，实际上是“字符数组管理 + 模式匹配算法”的组合拳。C语言里并没有原生字符串类型，字符串只是以\0结尾的char[]，这样的处理方式有多难受，写过的人都懂：你无法用sizeof拿到数组的长度、字符串拼接需要自己realloc、所有算法不得不在每个循环里反复调用strlen导致时间复杂度恶化。

我的建议是写一个统一的结构体，自己管理字符指针和长度：

c复制typedef struct {
    char *ch;      // 指向堆内存中的字符序列
    int length;    // 串的长度，不含结尾'\0'
} MyString;

赋值、拼接、截取都要重新分配空间，并用memcpy操作。为什么不用strcpy？因为strcpy依赖\0来判断拷贝终点，如果你要处理的是二进制数据或者包含空字符的内容，它会把数据拦腰截断。memcpy按字节数拷贝，没有这个隐患。处理串这种数据类型，一旦你想避开C语言的种种陷阱，从数据结构层的设计开始就要刻意，别顺手把系统的坑带进代码。

5.2 朴素匹配算法：能跑通，但别满足于它

串匹配，也就是在一个主串里找子串出现的起始位置，这个功能太常见了。编辑器的查找、数据库里的LIKE '%xxx%'、芯片验证的文本匹配脚本，都在频繁运行串匹配。

朴素匹配算法，简单粗暴地从主串的每个位置出发，和模式串逐个字符比较。一旦失配，模式串整体右移一格，主串指针也退回原位加1，重新开始比较。代码实现不超过20行，是每个学习者第一遍就能写出来的版本。

c复制int IndexNaive(const char *text, const char *pattern) {
    int n = strlen(text);
    int m = strlen(pattern);
    if (m == 0) return 0;
    for (int i = 0; i <= n - m; i++) {
        int j = 0;
        while (j < m && text[i + j] == pattern[j]) {
            j++;
        }
        if (j == m) {
            return i;
        }
    }
    return -1;
}

但朴素匹配的最坏情况复杂度是O(n*m)。比如主串是aaaaaaaab，模式串是aaab，每次比较到最后一个字符才失配，然后退回去重新比，大量比较都是重复的。在主串几十MB级别时，朴素匹配的消耗就让人无法忍受。

5.3 KMP的核心原理：已匹配的前缀里藏着未来

KMP算法的突破点在于：失配时，主串指针不回头，只移动模式串位置，利用模式串内部自身的重复结构决定移动多少。这个“自身的重复结构”要用一个next数组来记录。

构建next数组的思路是，找出模式串中每个前缀的最长相同前后缀长度，把它预处理出来。举例模式串ABABC，它的前缀AB没有相等的前后缀，next值是0；前缀ABA中，A是相同的前后缀，next值为1；前缀ABAB，AB是相同前后缀，next值为2。

具体求next的代码：

c复制void GetNext(const char *p, int *next) {
    int m = strlen(p);
    next[0] = -1;
    int k = -1;
    int j = 0;
    while (j < m - 1) {
        if (k == -1 || p[j] == p[k]) {
            ++j;
            ++k;
            next[j] = k;
        } else {
            k = next[k];
        }
    }
}

这里next[j]的含义是模式串中，当p[j]与主串失配时，j应该退回的新位置。而失配时模式串右移的距离是j - next[j]。next[0] = -1是因为第一个字符就失配时需要让主串前进并让模式串从0开始。这个数组单独看抽象得让人头冷，但画一次“字符串与模式比较到一半失配”的图就通了。

匹配实现如下：

c复制int IndexKMP(const char *text, const char *pattern) {
    int n = strlen(text);
    int m = strlen(pattern);
    int *next = (int *)malloc(sizeof(int) * m);
    if (next == NULL) return -1;
    GetNext(pattern, next);

    int i = 0;
    int j = 0;
    while (i < n && j < m) {
        if (j == -1 || text[i] == pattern[j]) {
            ++i;
            ++j;
        } else {
            j = next[j];
        }
    }
    free(next);
    if (j == m) {
        return i - j;
    }
    return -1;
}

可以把KMP的复杂度理解成一次“用模式串内信息换主串不回头”的交易。预处理 next 数组 O(m)，匹配过程 O(n)，总体 O(n+m)。对于日志关键词匹配、基因序列短串搜索这种场景，差距是数量级的。

5.4 回文串判断：从基础到偏门玩法

热词里出现了“回文串”、“二进制回文串”、“绝世好串”，本质上都在考察字符或二进制序列的对称性。回文串判断是个经典得不能再经典的入门题：判断一个串和它反转后的串是否相等。若要用栈来做，也可以把串的一半压栈，再逐一弹栈与后半段比较。

回文串有个更进阶的变体是“最长回文子串”，朴素做法O(n^3)，中心扩展法O(n^2)，Manacher算法能做到O(n)。很多算法题都从回文串切入，为了说明“为什么会需要动态规划、需要对称性优化”，它确实是个很好的观察窗口。但作为基础篇，先掌握判断回文和中心扩展两种方法就够用了，因为工作中直接写一个最长回文子串的场景不算多，而“判断id是否是回文串”这种小逻辑反而经常出现。

5.5 串的KMP和全栈项目之间是什么关系

热词里有一堆“全栈项目”、“前端后端”、“全栈开发”，和串的关联，其实是因为字符串匹配算法是各类搜索引擎、文本处理框架的地基。全栈项目本身不一定非得手写KMP，但你要用到grep、vscode的搜索、Elasticsearch的倒排索引、数据库的全文检索时，里面的核心逻辑要么是KMP要么是更现代的BM、Sunday、Rabin-Karp等算法。

全栈里常说的技术栈栈字和数据结构里的栈是巧合，不过这两个词常常一起出现在同一个招聘要求里，多少会让人困惑。我的理解是，技术栈是全栈工程师需要的框架、语言、工具链的集合名称，而数据结构栈则是一个具体的存储结构。两者不是一个维度的概念，不需强行关联。

6. 调试经验与常见问题速查手册

6.1 栈和队列最容易踩的四个坑

我把自己当年踩过的坑和辅导别人时反复出现的坑列个表，每条都是真实改代码改到怀疑人生的那种。

关于链式结构的free，补充一个边界情况：顺序栈里的data是整个栈唯一的堆内存块，销毁栈是安全操作；但链栈中的节点是逐个申请的，销毁时如果只free了top节点，剩下的节点就全部泄漏了，必须在循环里逐个销毁。销毁链栈时从top开始，每次先保存next再free当前节点，直到NULL为止。

6.2 KMP的next数组为什么总是算不对

很多人第一次写GetNext，要么越界，要么无限循环。最典型的问题是漏了next[0] = -1。如果初始不给next[0]设值，后面的k = next[k]在k等于-1时会先访问到垃圾值。还有一种是算法里if (k == -1 || p[j] == p[k])的k == -1条件忘了写。这个条件是用来说明“前缀匹配失败，又回到了起点”的关键，漏了它，碰上ABAB这类重复模式的串，数组就构建错。

调试时我建议用下面这种方式验证：模式串ABCDABD的next数组，正确结果应该是[-1, 0, 0, 0, -1, 0, 2]。你可以先手动算一遍这个结果，然后打日志比对。如果差了，就从模式串的前缀后缀相等关系出发逐步检查，别在那儿盯着代码发呆。把字符串缩短到三四个字符，用笔在纸上画出每一步k和j的取值，基本上一张表就能暴露问题。

6.3 内存管理到底怎么练

C语言的内存管理门槛不在于malloc你写不写得出来，而在于你对每一块内存在哪个函数里分配、在哪里释放、释放后指针会不会变成野指针，这几个问题的掌控力。我的经验是写基础数据结构特别是链式结构时，养成每一个malloc都配有注释的习惯。

比如压栈时malloc一个新节点，我会在旁边注释“该内存在Pop/ClearStack/DestroyStack中释放”。换而言之，内存不是“用完就丢”自动垃圾回收，内存的生命周期需要代码逻辑严格绑定。假如一个节点在某次出队操作里，指针被改没了但内存没free，那么那部分空间将永远泄漏。多做几次在线演示那种“写入数据几十万次后内存占用不断上涨”的实验，你就能理解C语言程序员为什么总把内存悬挂挂在嘴边。

6.4 几个问题排查的加密小技巧

实战经验分享：遇到段错误（Segmentation Fault），不要慌着到处加printf，先在你的代码里找有没有对空指针的直接解引用。比如我在写栈的Top函数时，经常一开始忘记判断栈空：

c复制int GetTop(SqStack *s) {
    if (s->top == -1) {
        // 这里要不要报错？返回什么？
    }
    return s->data[s->top];
}

一个好的处理是多设计一层返回布尔值的GetTopSafe(SqStack *s, int *out)，把安全性交给上游来确认。这在业务里也有同款逻辑：如果你的API返回的是一个内部资源对象，在资源不存在时到底是抛异常、返回null，还是返回一个错误码？想清楚这个接口契约，系统健壮性直接好一个档次。

7. 终章：试着自己把它融合起来

写出三种结构的C语言实现并不困难，真正见功力的是能不能不看课本把代码从头默写出来，以及拿到一个实际问题时能不能意识到栈、队列、串里的哪种结构能派上用场。

拿一个融合练习举例：写一个程序，读取一段C语言源码文本，检查括号是否匹配、在匹配过程遇到字符串常量时要处理转义字符。这个题目要求你同时使用串的遍历、栈的存储、和状态机一样的匹配逻辑。当你能做到这一步，你就不再是背题的初学者，而是一个把数据结构内化成思维工具的人。

再比如字符串的“回文判断”结合栈来做，入栈一半再弹出一半比较。这种题目练的不是某一招，而是组合的能力，现实中多数问题本来也是组合而来。

我在实际教学中还有一个心得：数据结构课本代码要“背”但别死背。你应该能脱离课本提笔就写，写完后遇到边界条件会自己停下来想一想，这才是掌握。默写时也不是从第一行默写到最后一个}，而是先默写结构体定义和核心操作的逻辑分支，然后填充细节。这种写法和读代码完全不同，它逼着你理解内存布局和指针走动，而不是仅仅做翻译。

我的建议是大家把每个结构的操作列成一页纸的清单，然后看着清单把代码写出来，写完再看自己哪一行的错误多。多练几轮后，你会发现这类基础数据结构的代码感会像肌肉记忆一样自然涌现。

最后再分享一个看似微小但对我帮助极大的习惯：给每个数据结构写一个尽可能覆盖边界条件的测试函数，而不是只在main里跑一次“看起来没问题”的demo。测试函数内部依次测空栈压栈弹栈、压到超出初始容量、循环队列到满再出队、把若干数据清空后再操作等等。这个习惯可以让你在配置上多花20%的时间，但排查Bug上至少能省掉200%的时间。三十岁以后的我回看本科时写的代码，最遗憾的不是写得不够花哨，而是始终没有认真地给自己写一套能反复跑的测试集，直到工作被线上问题反复毒打之后才补上这一课。基础结构虽然简单，该守的工程纪律一步都少不得。