《剑指 Offer》学习记录：题 22：链表中倒数第 k 个结点

目录

• 题 22：链表中倒数第 k 个结点
  • 题干
  • 测试样例
• 蛮力法
  • 方法思路
  • 题解代码
  • 时空复杂度
• 快慢指针
  • 方法思路
  • 题解代码
  • 时空复杂度
• 栈辅助法
  • 方法思路
  • 题解代码
  • 时空复杂度
• 递归法
  • 方法思路
  • 题解代码
  • 时空复杂度
• 参考资料

题 22：链表中倒数第 k 个结点#

题干#

输入一个链表，输出该链表中倒数第 k 个结点。为了符合大多数人的习惯，本题从 1 开始计数，即链表的尾结点是倒数第 1 个结点。例如一个链表有 6 个结点，从头结点开始它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个结点是值为 4 的结点。——《剑指 Offer》P134

测试样例#

链表的数据结构定义如下(Python)：

Copy Highlighter-hljs
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

若传入的头结点 head 指向的链表结构如图所示：

要求返回倒数第 4 个结点，也就是结点 2：

蛮力法#

方法思路#

蛮力法的思路比较简单，设表长为 n，为了得到第 n - k 个结点，就需要先获得表长。首先先遍历一遍链表求出表长，然后再遍历一次链表得到第 n - k 个结点。

题解代码#

Copy Highlighter-hljs
class Solution:

    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        count = 0

        ptr = head
        while ptr:    #遍历链表获得表长
            ptr = ptr.next
            count = count + 1

        ptr = head    #遍历到 n - k 个结点
        for i in range(count - k):
            ptr = ptr.next
        
        return ptr

时空复杂度#

设表长为 n，第一次遍历需要遍历整个链表，第二次遍历 n - k 次。得出 T(n) = 2n - k，进而得到 O(n) = n。
由于不需要任何辅助空间，蛮力法的空间复杂度为 O(1)。

快慢指针#

方法思路#

快慢指针的想法比较巧妙，也就是可以定义 2 个指针。先使用第一个指针遍历链表到表尾，此时若第二个指针和第一个指针差距 k 个结点，就可以直接得到第 n - k 个结点。例如对于链表 [1,2,3,4,5] 求倒数第 2 个结点，可以先让快指针先出发遍历 2 个结点，慢指针先不动。

接下来同时移动 2 个指针，当快指针遍历完毕时，由于慢指针晚出发 2 个结点，所以慢指针此时指向的就是倒数第 2 个结点。

题解代码#

Copy Highlighter-hljs
class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        fast_ptr = head
        slow_ptr = head

        for i in range(k):    #快指针先出发 k 个结点
            ptr = ptr.next

        while ptr:    #快慢指针同时向前遍历
            ptr = ptr.next
            slow_ptr = slow_ptr.next

        return slow_ptr

时空复杂度#

设表长为 n，遍历整个链表得到时空复杂度 O(n) = n。注意此时虽然时间复杂度和蛮力法一样，T(n) = n 有可能比蛮力法低。
由于不需要任何辅助空间，空间复杂度为 O(1)。

栈辅助法#

方法思路#

获得倒数第 k 个结点，可以认为是逆序链表后取到第 k 个元素。此时可以借助一个栈结构来让链表逆序，例如对于链表 [1,2,3,4,5] 求倒数第 2 个结点，可以先遍历一遍链表，将所有的数据元素入栈。此时就得到了链表的逆序序列，出栈栈顶的 k 个元素就能得到需要的结点。

题解代码#

Copy Highlighter-hljs
class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        a_stack = []
        ptr = head

        while ptr:    #链表所有元素入栈
            a_stack.append(ptr)
            ptr = ptr.next

        for i in range(k):    #栈顶 k 个元素出栈
            ptr = a_stack.pop()

        return ptr

时空复杂度#

设表长为 n，遍历整个链表得到时空复杂度 O(n) = n。注意此时虽然时间复杂度和蛮力法一样，但是 T(n) = n + k 比蛮力法低。
由于需要一个栈结构作为辅助空间，空间复杂度为 O(n)。

递归法#

方法思路#

获得倒数第 k 个结点，可以认为是遍历链表后通过回溯取到第 k 个元素。此时可以使用递归遍历完整个链表，然后回溯 k 次得到倒数第 k 个结点，接着再将这个结点传递回去。

题解代码#

Copy Highlighter-hljs
class Solution:
    num = 0    #全局变量记录回溯了几次

    def fun(self, head: ListNode, k: int) -> ListNode:
        if head.next == None:    #遍历完链表，开始回溯
            Solution.num = Solution.num + 1
            return head

        ptr = self.fun(head.next, k)
        Solution.num = Solution.num + 1
        if Solution.num > k:    #回溯次数 k 次
            return ptr    #传递倒数第 k 个结点
        else:
            return head    #返回递归层次所在结点

    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        Solution.num = 0    #力扣需要手动初始化全局变量
        return self.fun(head, k)

时空复杂度#

设表长为 n，需要遍历整个链表，然后回溯 n 次。得出 T(n) = 2n，进而得到 O(n) = n。
由于递归需要额外的辅助空间，空间复杂度为 O(n)。

参考资料#

《剑指 Offer(第2版)》，何海涛 著，电子工业出版社
双指针，栈，递归3种解决方式，有两种击败了100%的用户