题解 | #链表中倒数最后k个结点#

题目描述

输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。

如果该链表长度小于k，请返回一个长度为0的链表。

解决思路

1.栈

思路简单清晰，空间复杂度高些

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。
     * 如果该链表长度小于k，请返回一个长度为 0 的链表。
     * 
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pHead ListNode类
     * @param k int整型
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) 
    {
        stack<ListNode*> myStack;

        if(pHead==nullptr||k==0)return nullptr;
        while (pHead != nullptr)
        {
            myStack.push(pHead);
            pHead = pHead->next;
        }

        if (myStack.size() < k)return nullptr;
        ListNode* vhead = myStack.top();
        myStack.pop();

        while (--k > 0)
        {
            ListNode* temp = myStack.top();
            myStack.pop();
            temp->next = vhead;
            vhead = temp;
        }
        return vhead;

    }
};

2.双指针

思路

fastPtr先走k步，之后slowPtr和fastPtr以相同速度前进，当fastPtr==nullptr时，slowPtr就是需要结果。

代码

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。
     * 如果该链表长度小于k，请返回一个长度为 0 的链表。
     * 
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pHead ListNode类
     * @param k int整型
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) 
    {
        if(pHead==nullptr||k==0)return nullptr;
        ListNode* fastPtr=pHead;
        ListNode* slowPtr=pHead;
        while(k>0)
        {
            if(fastPtr==nullptr)return nullptr;
            fastPtr=fastPtr->next;
            k--;
        }
        while(fastPtr!=nullptr)
        {
            fastPtr=fastPtr->next;
            slowPtr=slowPtr->next;
        }
        return slowPtr;
    }
};

3.链表反转后操作

麻烦而且一点都不好写

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。
     * 如果该链表长度小于k，请返回一个长度为 0 的链表。
     * 
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pHead ListNode类
     * @param k int整型
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) 
    {
        if(pHead==nullptr||k<=0)return nullptr;
        ListNode* pre=nullptr;
        ListNode* cur=pHead;
        ListNode* nex=nullptr;
        while(cur!=nullptr)
        {
            nex=cur->next;
            cur->next=pre;
            pre=cur;
            cur=nex;
        }
        cur=pre;
        pre=nullptr;
        nex=nullptr;
        while(k-->0)
        {
            if(cur==nullptr)return nullptr;
            nex=cur->next;
            cur->next=pre;
            pre=cur;
            cur=nex;
        }
        return pre;
    }
};