前言

这道题和BM1中的思路有些许类似，整体不难。

---

题目

描述
输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。
如果该链表长度小于k，请返回一个长度为 0 的链表。

数据范围：$0\le n\le 10^5$ ，$0\le ai\le 10^9$ ，$0\le k\le 10^9$
要求：空间复杂度 $O(n)$，时间复杂度 $O(n)$
进阶：空间复杂度 $O(1)$，时间复杂度 $O(n)$

例如输入{1,2,3,4,5},2时，对应的链表结构如下图所示：
其中蓝色部分为该链表的最后2个结点，所以返回倒数第2个结点（也即结点值为4的结点）即可，系统会打印后面所有的节点来比较。

解决方案一

1.1 思路阐述

题目有两个标准，思路一是立马能想到的。
空间复杂度 $O(1)$，时间复杂度$O(n)$
两次遍历即可；

第一次遍历整个链表获取链表长度；

第二次遍历链表长度减去k值的长度，这个长度就是倒数第几个节点的位置

接着对于特殊情况单独判断一下，比如k值大于链表长度，那么返回一定是nullptr，否则就遍历节点再返回指定节点开始的链表。

1.2 源码

class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pHead ListNode类
     * @param k int整型
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        int count = 0;
        ListNode* flagHead = pHead;
        while (pHead) {
            count++;
            pHead = pHead->next;
        }
        count = count - k;
        if (count < 0) {
            return nullptr;
        } else {
            while (count--) {
                flagHead = flagHead->next;
            }
            return flagHead;
        }

    }
};

解决方案二

2.1 思路阐述

对于思路一，我其实最主要的还是遍历，实际存储并没有消耗什么空间。

思路二在BM1反转链表中也有体现。

这道题换个角度，倒数k个节点不就是正数n-k个节点嘛，从尾部开始遍历k个节点。

空间复杂度 $O(n)$，时间复杂度 $O(n)$

那这个思路特别符合数据结构中的栈这一概念，我们只需要将链表节点全部压入栈，接着再出栈k个节点，那么最后一个节点对应的链表就是我们要的链表了。

2.2 源码

#include <stack>
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        stack<ListNode *> stack;//栈
        ListNode *answer=NULL;//返回值
        while(pHead)//全部入栈
        {
            stack.push(pHead);
            pHead=pHead->next;
        }
        if(k>stack.size()||stack.size()==0) //判断特殊值
            return answer;
        for(int i=0;i<k;i++)
        {
            answer=stack.top();
            stack.pop();
        }
        return answer;
    }
};

总结

这题比较简单，主要就是链表遍历，同时也复习了一下栈的使用。