LeetCode题目笔记——面试题 02.02. 返回倒数第 k 个节点

题目描述

实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。

注意：本题相对原题稍作改动

示例：

输入： 1->2->3->4->5 和 k = 2
输出： 4
说明：

给定的 k 保证是有效的。

题目链接

题目难度——简单

方法一：借用一个栈

  由于链表的特性，不能提前得知总体元素数量，所以我们可以借助一个栈，一边遍历链表一边将元素入栈，最后返回倒数第k个元素就行，这种方法可以借助不同语言的特性来做。比如Python就可以很轻松的用列表来表示，C++则稍微麻烦一点。

代码/Python

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def kthToLast(self, head: ListNode, k: int) -> int:
        stack = []
        cur = head
        while cur != None:
            stack.append(cur.val)
            cur = cur.next
        
        return stack[-k]

代码/C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int kthToLast(ListNode* head, int k) {
        stack<int> helper;
        ListNode *cur = head;
        while(cur != NULL){
            helper.push(cur->val);
            cur = cur->next;
        }
        while(--k){
            helper.pop();
        }
        return helper.top();
    }
};

方法二——双指针

  我们可以用两个指针p1和p2，首先让p1走k步，然后让p1和p2一起走，直到p1到达尾部，返回p2即可。因为此时他们之间相差就是k个位置。

代码/C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int kthToLast(ListNode* head, int k) {
        ListNode *p1 = head, *p2 = head;
        while(k){
            p1 = p1->next;
            k--;
        }
        while(p1){
            p1 = p1->next;
            p2 = p2->next;
        }
        return p2->val;
    }
};

方法三——递归

  还可以用递归的方法来做，具体的思路就是当到达末尾元素是开始返回，同时计数当前返回的是第几个元素，碰到第k个时就是答案。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int globalK = 0;
    int kthToLast(ListNode* head, int k) {
        if(head->next == NULL){
            return head->val;
        }
        int val = kthToLast(head->next, k);
        if(++globalK >= k){
            return val;
        }
        else{
            return head->val;
        }
    }
};

总结

  三种方法时间都是O(N)，第一种用到了额外的结构，所以空间是O(N)。