链表倒数第m个元素怎么找？双指针一次遍历，从原理到边界全拆解

先说个有意思的现象：很多人第一次看到“求链表的倒数第m个元素”这道题，第一反应往往是“这有什么难的，先遍历一遍数出链表长度n，再遍历一遍走到第n-m+1个节点不就完事了”。可是真上手写代码就会发现，这个解法总显得有点笨，而且一旦面试官追问一句“能不能只遍历一次”，立刻就傻眼了。

这道题之所以能成为数据结构教材里的常驻习题，又被各大厂面试官反复翻牌，就是因为它同时考察了三件事：你懂不懂链表的物理结构、你有没有倒数的空间感、你能不能跳出“数组思维”去找更优解。顺着这个思路往下走，你会发觉这道题还真不是随便写几行代码就能糊弄过去的。

习题3.5 求链表的倒数第m个元素，核心考点就两个字：双指针。更准确地说，是快慢指针在一次遍历里完成“定位倒数位置”这件事。下面我把这道题从原理、代码、边界条件到真实工程应用全部拆开讲透。

1. 为什么一个简单的查找题，能卡住一大片人

1.1 数组思维是最大的拦路虎

凡是写过几年代码的人，对arr[n-m]这种取数方式都太熟悉了。数组在内存里是一段连续空间，你给它一个下标，它直接用“基地址+偏移量”把元素取出来，时间复杂度O(1)。这种随机访问能力被我们当成了天经地义的事，以至于看到链表时会下意识想：我能不能像数组一样直接算出倒数第m个的位置？

很遗憾，链表不行。单链表的每个节点只存了next指针，你想知道某个节点后面还有多少个节点，唯一的方式就是顺着指针一个个走。也就是说，链表的“长度”和“某个节点是第几个”这两个信息，在你拿到头节点的那一刻是完全未知的。

这就导致一个很尴尬的局面：你想找倒数第m个元素，但不知道链表有多长，你根本没法从头部出发计算“倒数第m个到底正数第几个”。所以很多人第一版代码就是老老实实遍历两次。这很正确，但确实不够优雅。

1.2 题目真正的潜台词：一次遍历能不能做到

很多教材不会明说，但习题3.5这类题放在“链表”章节的深水区，潜台词其实是要求你在O(n)时间、O(1)空间里完成查找，并且只遍历一次。为什么有这个隐含要求？

因为链表本身就是为“顺序访问”设计的结构，如果你用两次遍历，时间复杂度虽然还是O(n)（复杂度常数翻倍），但在实际工程场景中，链表可能存储在磁盘上、可能通过网路读取、甚至每个节点访问都伴随一次昂贵的IO操作——这时候每多遍历一次，成本都是实打实的线性增长。所以“尽量少的遍历次数”在工程里不是炫技，而是刚需。

1.3 一个直观的类比

你可以把链表想象成一条长长的单行道，你站在起点，想知道这条路上的倒数第m个路牌上写了什么。你没有地图，不知道总共有多少块路牌，也没有办法回头。

两次遍历的思路是：先走到终点数清楚一共n块路牌，再重新走回起点，走n-m+1步停下。

双指针的思路是：找个人和你一起走。你先往前走m步，然后两个人同步匀速往前，你到终点停下来时，同伴所在的位置就是倒数第m块路牌。全程只走了一遍，而且不需要预先知道总长度。

这个类比几乎就是双指针解法的全部思想。

2. 双指针解法：快指针先垫步，慢指针随后追上

2.1 核心原理：距离差就是倒数位置

双指针解法的本质，是制造一个长度固定的“滑动窗口”。快指针先出发走m步，此时快慢指针之间隔着m个节点。然后快慢指针以同样的速度同步前进。当快指针走到链表末尾（指向null）时，慢指针距离末尾刚好也是m步——慢指针指向的就是倒数第m个节点。

这里有一个非常关键的理解点：为什么快指针先走m步，而不是m-1步？这取决于你对“倒数第m个”的定义方式以及代码写法。如果快慢指针之间隔着m个节点，那么快指针到末尾时，慢指针正好是倒数第m个。如果快指针先走m-1步，二者之间只隔着m-1个节点，那么当快指针走到尾节点（而非null）时，慢指针才是倒数第m个。两种写法都能实现，但前者以“null”为结束条件，后者以“最后一个节点”为结束条件，代码逻辑上稍微有一点差别。

我用第一种写法作为主推方案，因为它的结束条件判断更直观：快指针指向null，意味着它已经越过了链表末尾。

2.2 C语言/C++实现

习题3.5既然出现在教材里，大概率是C/C++语言环境。先定义链表节点结构体：

c复制typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

核心函数如下：

c复制ListNode* findMthFromEnd(ListNode* head, int m) {
    if (head == NULL || m <= 0) {
        return NULL;
    }

    ListNode *fast = head;
    ListNode *slow = head;

    // 快指针先走m步
    for (int i = 0; i < m; i++) {
        if (fast == NULL) {
            // m大于链表长度，返回NULL
            return NULL;
        }
        fast = fast->next;
    }

    // 快慢指针同步前进
    while (fast != NULL) {
        fast = fast->next;
        slow = slow->next;
    }

    return slow;
}

这里有几个地方需要特别注意：

• for循环里要检查fast == NULL。如果链表长度小于m，快指针在走完m步之前就已经掉出链表末尾，此时直接返回NULL——因为根本不存在倒数第m个元素。
• while (fast != NULL)循环退出时，fast恰好是NULL，此时slow就是倒数第m个节点。自己拿个长度为5的链表，m=2，在纸上画一画，一画就通了。

2.3 Python版本

Python写链表虽然平时用得少，但刷题和面试手写时很常见：

python复制class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


def find_mth_from_end(head: ListNode, m: int) -> ListNode:
    if not head or m <= 0:
        return None

    fast = slow = head

    for _ in range(m):
        if not fast:
            return None
        fast = fast.next

    while fast:
        fast = fast.next
        slow = slow.next

    return slow

Python写起来更简洁，但思路完全一样。这里s = head之后两个变量指向同一个节点对象，注意不要误以为slow和fast是“复制”出来的两个链表——它们只是指向链表节点的引用/指针，移动指针不会改变链表本身的结构。

2.4 两种写法变体：先走m步 vs 先走m-1步

我再贴一下第二种写法，方便做个对比。这种写法在《剑指Offer》等面试资料里也常出现，你需要能看懂，因为有些面试官习惯这么写：

c复制ListNode* findMthFromEnd2(ListNode* head, int m) {
    if (head == NULL || m <= 0) {
        return NULL;
    }

    ListNode *fast = head;
    ListNode *slow = head;

    // 快指针先走m-1步
    for (int i = 0; i < m - 1; i++) {
        if (fast->next != NULL) {
            fast = fast->next;
        } else {
            return NULL; // m大于链表长度
        }
    }

    // 快慢指针同步走，直到快指针到达尾节点
    while (fast->next != NULL) {
        fast = fast->next;
        slow = slow->next;
    }

    return slow;
}

这两种写法的区别可以这样理解：第一种方案把“快指针到达NULL”作为终止标志，慢指针离末尾的距离是“m步”，当你想要“倒数第m个节点”时，它会指向正确位置。第二种方案把“快指针到达最后一个节点”作为终止标志，慢指针离末尾的距离是“m-1步”，同样指向倒数第m个节点。

两者均正确，我推荐先走m步的方案，因为循环条件fast != NULL清晰直观，不易在边界问题上翻车。第二种在m=1时需要走0步，逻辑上也比较顺，但第一次接触容易把“m-1”和“倒数位置”搞混。你可以任选一种记住，但最好把另一种也看懂，避免面试官问“你还能怎么实现”时无从下手。

3. 边界条件：这道题真正的得分点都在这里

很多人刷题时候有个习惯：主逻辑写对了就收工，边界条件根本不管。但说实话，像习题3.5这种题，面试官或者老师真正想看的，恰恰是你对边界情况的处理。链表题的坑，十有八九都埋在边界里。

3.1 空链表

head为NULL，直接返回NULL。这个判断写在函数开头，所有情况一视同仁。没啥好说的，但漏掉它，调用者拿到的就是悬空指针，在C/C++里直接崩溃。

3.2 m小于等于0

m=0时，题目问“倒数第0个元素”，这个在数学意义上是没有定义的。m为负数就更离谱了。所以统一返回NULL，不做特殊处理。有的实现会把m=0特殊处理成返回尾节点，但你最好先明确题目定义——绝大多数情况下，m是正整数。

3.3 m刚好等于链表长度

这是最容易被忽视但最容易出错的边界之一。假设链表长度是5，m=5，倒数第5个元素就是头节点。我们用先走m步的方案来看：

• 快指针从头开始走5步，走到NULL（因为链表只有5个节点，第5步后快指针从第5个节点跳到NULL）。
• 此时slow还在head处，进入while (fast != NULL)循环，条件不成立，直接返回slow。
• 返回结果就是head，完美。

但如果你在快指针走完之后没有检查“fast是否为空”就继续同步走，就会出问题。不过代码里for循环后fast为NULL是允许的——它恰恰表示m等于链表长度这个正确场景，所以不能在for循环里一看到fast为NULL就返回NULL，要先区分“走完m步后为NULL”和“走了不到m步就为NULL”。这个区分在代码里就是for循环内判断和for循环后判断的差别。

3.4 m大于链表长度

假设链表长度是5，m=7。快指针走第6步的时候就已经是NULL了。这时候必须在for循环内部检查，一旦发现fast为NULL就立即返回NULL。如果这步漏了，后面while循环里访问fast->next就会造成空指针解引用，程序直接崩。

3.5 链表只有一个节点

此时n=1。如果m=1，快指针走1步到NULL，slow停在头节点，返回头节点，正确。如果m>1，for循环内检查发现快指针为NULL，返回NULL，正确。这个情况在两个边界条件的夹击下已经天然被覆盖了。

3.6 环形链表会死循环吗

这道题的标配输入是单链表，默认无环。但如果你在刷题平台或者面试追问中遇到“链表可能有环，怎么处理”的变体，用双指针这个思路会死循环——快指针永远追着环跑，永远到不了NULL。

这时可以在快指针走的每一步都判断是否回到头节点，或者用经典的快慢指针检测环（快指针每次走两步，慢指针每次走一步，如果相遇说明有环）。不过说实话，这是把“求倒数第m个元素”和“判断环形链表”两个问题缝合在一起了，属于进阶玩法，初学者先把无环场景吃透再说。

3.7 一份测试用例清单

为了让你验证代码时心里有数，我列一份测试用例表，你写完代码后可以照着逐条跑：

第九条是很多人的盲区：链表只有一个节点，m=2应该返回NULL，不要误以为返回这个节点本身。

4. 不止双指针：其他解法与为什么最终推荐双指针

4.1 方法A：先求长度，再二次遍历

这是最直白的解法，也最容易被初学者想到。

c复制ListNode* findMthFromEnd_2pass(ListNode* head, int m) {
    if (head == NULL || m <= 0) {
        return NULL;
    }

    int len = 0;
    ListNode *cur = head;
    while (cur != NULL) {
        len++;
        cur = cur->next;
    }

    if (m > len) {
        return NULL;
    }

    int steps = len - m;
    cur = head;
    while (steps--) {
        cur = cur->next;
    }
    return cur;
}

时空复杂度：时间O(n)，遍历了两遍；空间O(1)。这个方案没什么毛病，代码也对，但就是不够“灵性”。在工程上如果链表在磁盘上或者节点数据很大，多一次遍历意味着多一倍的IO开销。在面试场合，你给出这个方案后，面试官大概率会追问一句：“能不能优化到只遍历一次？”所以它能作为保底方案，但不建议作为最终答案。

4.2 方法B：用栈存所有节点，再弹栈m次

思路也很简单：遍历一遍链表，把所有节点指针压入栈，然后弹出m次，最后一次弹出的就是倒数第m个节点。

c复制ListNode* findMthFromEnd_stack(ListNode* head, int m) {
    if (head == NULL || m <= 0) {
        return NULL;
    }

    ListNode *cur = head;
    int count = 0;
    while (cur != NULL) {
        count++;
        cur = cur->next;
    }

    if (m > count) {
        return NULL;
    }
    cur = head;
    int target = count - m + 1;
    while (--target) {
        cur = cur->next;
    }
    return cur;
}

等一下，这里我其实用了两次遍历。如果纯用栈，可以只压栈一遍，然后弹栈m次，不需要先算链表长度。空间复杂度是O(n)，因为你要为每个节点存一份指针。

和双指针相比，空间从O(1)变成了O(n)，在链表特别长的情况下，栈内存占用会很夸张。虽然很好理解，但在工程上它不是首选。

4.3 方法C：递归回溯

递归是计算链表长度和定位的一个巧妙思路。先递归到链表末尾，然后在回溯阶段计数：

c复制ListNode* result = NULL;

ListNode* dfs(ListNode* head, int m, int& count) {
    if (head == NULL) {
        return NULL;
    }
    dfs(head->next, m, count);
    count++;
    if (count == m) {
        result = head;
    }
    return result;
}

这个写法很漂亮，但是有两个致命问题：

• 如果链表非常长（比如几万、几十万个节点），递归深度会耗尽函数调用栈，导致栈溢出。C语言默认栈空间也就几MB，撑不住深递归。
• 代码可读性对初学者不友好，调试起来也比较费劲。

双指针解法在时间O(n)、空间O(1)的双重约束下都能满足，而且代码极其简洁。这正是它成为标准答案的根本原因。

4.4 一份解法对比表

5. 面试官与考试题的升级追问：你能举一反三吗

5.1 升级版1：删除链表的倒数第m个节点

这是习题3.5的经典变体，LeetCode第19题。思路几乎一样，只不过你要在找到倒数第m个节点的同时，找到它的前驱节点，然后修改前驱的next指针。

实现上可以用一个哑结点（dummy node）来规避“删除头节点”的特殊情况：

c复制ListNode* removeNthFromEnd(ListNode* head, int m) {
    ListNode dummy = {0, head};
    ListNode *fast = NULL, *slow = NULL;
    
    fast = &dummy;
    slow = &dummy;

    // 快指针先走m+1步，让slow最终指向待删除节点的前驱
    for (int i = 0; i < m + 1; i++) {
        if (fast == NULL) return head;
        fast = fast->next;
    }

    while (fast != NULL) {
        fast = fast->next;
        slow = slow->next;
    }

    // slow->next就是要删除的节点
    ListNode *toDelete = slow->next;
    slow->next = toDelete->next;
    free(toDelete);

    return dummy.next;
}

这里为什么走m+1步？因为我们要的是“待删除节点的前驱”。快指针先走m+1步后，慢指针和快指针之间拉开m+1个节点的距离，当快指针到NULL时，慢指针就在倒数第m+1个节点上，恰好是目标节点的前驱。这个思想就是双指针距离差的活用。

5.2 升级版2：找链表的中间节点

快指针每次走两步，慢指针每次走一步。当快指针到底时，慢指针正好在中间。

c复制ListNode* findMiddle(ListNode* head) {
    if (head == NULL) return NULL;
    ListNode *slow = head, *fast = head;
    while (fast != NULL && fast->next != NULL) {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

这个变体在“判断回文链表”的题目里很常见：先用快慢指针找到中间节点，然后把后半部分逆序，再跟前半部分逐一对比。

5.3 升级版3：链表长度未知，且只允许遍历一次，返回倒数第m个节点的值

有些题目要求你返回val而不是节点指针，这很简单，拿到节点后返回node->val即可。

5.4 升级版4：如果顺着题目多想一步——倒数第m个，m比链表长度还大怎么办

你的代码必须返回NULL或抛异常，而不是崩溃。这在考试里也是踩分点。很多人主循环写对了，结果忘了在for循环里判断fast == NULL，一跑测试用例7就崩，白白丢分。

5.5 升级版5：单向链表只有next指针，双向链表呢

如果是双向链表，每个节点有prev指针，找倒数第m个根本不需要双指针——直接从尾节点往前回退m步即可。但教材里这道题的考点恰恰是“在只有next指针的单向链表里完成逆向定位”，所以双指针是最佳答案。反过来想，这也是为什么教科书会把这道题放在“单链表”的小节后面。

6. 从习题到工程：链表倒序查找的实际用武之地

6.1 日志系统里的滑动窗口淘汰

很多日志系统会把日志按时间顺序组织成链表结构，每个节点代表一条日志。当日志总量超过阈值时，需要淘汰最旧的一批日志，而“保留最近m条、删除更早的”这个操作，本质上就是找到倒数第m个节点然后把前面的链表全部释放。这个场景和“求倒数第m个元素”完全同构，双指针解法可以直接套用。

6.2 流式数据的滑动窗口统计

你在做实时指标统计时，数据是一个接一个到达的，你不知道总量有多少，只想维护最近N个数据的窗口。用链表加双指针的思路，可以让“窗口尾部”的指针跟着“窗口头部”同步滑动，每次新增一个数据就移动一次，窗口内的元素集合天然就是“倒数N个”。这也是滑动窗口算法在链表物理结构上的直接体现。

6.3 内存池与缓存淘汰

在许多嵌入式系统和网络框架里，内存块和缓存项经常组织成链表。LRU缓存淘汰算法里有一个hot区域、一个cold区域，实质上就是两条链表。当你需要从链表的倒序方向找到某个最近的命中项时，双指针思想能帮你避免反复从头遍历。

6.4 从“链表 芯片设计”这个热词聊聊

“链表”这个词在芯片设计领域也常出现，但含义不太一样。芯片设计里，特别是FIFO（先入先出队列）管理、寄存器链和片上网络的路由表设计中，经常用链式结构管理空闲资源或跟踪请求的先后顺序。比如一个硬件任务队列，按提交时间挂成链表，调度器想找“从尾部倒数第m个待处理任务”做优先级调整，这个算法就能以很少的状态寄存器实现。因为硬件里不能无限开数组，双指针这种用两个寄存器就能实现的思想反倒非常契合硬件资源受限的场景。虽然不像软件刷题那么直接对应，但抽象的指针滑动思想是同一个。

6.5 为什么工程里直接写裸链表不多

实话实说，现代工程里直接操作裸链表的场景越来越少了。高级语言的标准库里基本都封装好了（比如Python的list、C++的std::list、Java的LinkedList），普通业务开发根本不关心底层怎么找倒数第m个元素。但这道题的意义不在“使用场景”，而在思维训练——它能逼你理解指针移动的本质，理解“向前走m步再一起走”这种空间换时间的思想。这个思想在后续学树、图、滑动窗口、TCP拥塞控制（滑动窗口协议）时都会被反复用到。

7. 我的个人实战体会与建议

最后分享几个我在实际教学和面试中总结的经验，照着做能少踩很多坑。

第一，千万别只背代码。这道题的代码写出来很容易，但如果你不理解快慢指针之间“相距m步”的本质，面试官稍微一变体（比如删除倒数第m个）你就懵了。我见过太多候选人能默写原题，但一问“为什么要快指针先走m步而不是m-1步”就支支吾吾。你能不能用日常语言把这个原理讲清楚，往往是区分背题选手和真懂选手的分水岭。

第二，边界条件一定要在代码里写成显式判断，不要寄希望于输入数据足够规范。我见过有人写出的代码在链表长度恰好等于m时返回了NULL——因为他在for循环里一看到fast为NULL就直接return NULL了，根本没有区分“走完m步后为NULL”和“提前为NULL”。这两种情况在代码里必须分开处理，否则测试用例6就会挂。

第三，考试或面试时，可以先讲讲两次遍历的朴素方案，再切换到双指针方案，这样能体现出你有“从可行解到最优解的优化思维”。哪怕最后写出来的代码就是双指针，这个“思考路径”本身也是加分项。反过来，如果你一上来就直接写双指针，遇到有些面试官反而会怀疑你是不是背了题。

第四，关于代码里的空指针判断，C/C++选手尤其需要小心。写完代码后养成一个习惯：画一遍带头节点和3个元素的链表，把m分别设为1、3、4跑一遍，确认指针确实指到期望的位置而不是越界。这比背任何测试用例都管用。

习题3.5这道题说难不难，说简单也不简单。它最大的价值在于让你养成“双指针思维”和“边界条件意识”，这两个能力在后续几乎所有数据结构题目里都会反复用到。把我上面的代码原样跑通不算本事，能在纸上把每一步的指针指向画出来、能把每种边界情况都解释清楚，才算真正把这道题吃透了。