链表中倒数第k个结点---快慢指针 or 一次递归迭代解决

题目

oj平台

法一：递归方式

C++函数递归：

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        this->k = k;
        return getNode(head);
    }
private:
    int k;
    ListNode* getNode(ListNode* head){
        if(!head)
            return nullptr;
        ListNode* p = getNode(head->next);
            k--;
        if(k==0)
            return head;
        return p;
    }
};

C++迭代模拟递归：

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        vector<ListNode*>St;
        while(head){
            St.push_back(head);
            head = head->next;
        }
        while(--k){
            St.pop_back();
        }
        return St.back();
    }
};

Go语言函数递归：

var n int
func getKthFromEnd(head *ListNode, k int) *ListNode {
    n = k
    return getNode(head)
}
func getNode(head *ListNode) *ListNode{
    if head==nil{
        return nil
    }
    node := getNode(head.Next)
        n--;
    if n==0{
        return head
    }

    return node
}

Go语言切片模拟递归：

func getKthFromEnd(head *ListNode, k int) *ListNode {
    St := []*ListNode{}
    for head!=nil {
       St = append(St,head)
        head = head.Next
    }
    for ;k>1;k-- {
        St = St[:len(St)-1]
    }
    return St[len(St)-1]
}

法二：快慢指针解决

C++快慢指针：

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode* fast = head;
        ListNode* slow = head;

        while (fast && k > 0) {
            fast = fast->next;
            k--;
        }
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }

        return slow;
    }
};

Go语言快慢指针

func getKthFromEnd(head *ListNode, k int) *ListNode {
    fast, slow := head, head
    for ;fast != nil && k > 0;k-- {
        fast = fast.Next
    }
    for fast != nil {
        fast = fast.Next
        slow = slow.Next
    }
    return slow
}