剑指offer-链表中倒数第K个节点

问题

题目：[链表中倒数第K个节点]

思路

利用递归的特点，不过我倒是没有对算法进行优化，没有能优化到O(K)。
因为我是递归到底部之后，再回来的时候判断K。所以无论如何都要走回来。

代码

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(!pListHead) return NULL;
        int cnt = 0;
        ListNode* ret = NULL;
        helper(pListHead, k, cnt, ret);
        return ret;
    }
private:
    void helper(ListNode* head, unsigned int k, int& cnt, ListNode*& ret){
        if(NULL == head->next ){
            cnt = 1;
            if(cnt == k)
                ret = head;
        }
        else{
            helper(head->next, k, cnt, ret);
            ++cnt;
            if(cnt == k)
                ret = head;
        }

    }
};

思路1

两根指针的思路，一个先走K-1步，另外一个再开始走。这样当先走的到达尾巴之后，下一个刚好距离尾巴是K。
既然考察代码鲁棒性：我觉得是有一个参数无符号数的问题，这个参数要特别小心，因为如果K==0,那么k-1可不是个负数。

代码1

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(!pListHead) return NULL; // 指针为空
        if(!k) return NULL;         // 特别小心，无符号数k-1可不是-1，是一个很大的正数
        ListNode* p = pListHead;
        for(int i = 0; i < k-1; ++i){
            p = p->next;
        }
        if(!p ) return NULL;        // 这是判断当k的数字大于链表长度的情形
        ListNode* ans = pListHead;
        while( p->next ){
            p = p->next;
            ans = ans->next;
        }
        return ans;
    }
};