链表中倒数最后k个结点

typedef struct ListNode ListNode;
struct ListNode* FindKthToTail(struct ListNode* pHead, int k )
{   
    //合法性判断
    if(pHead == NULL || k == 0)
    {
        return NULL;
    }

    int i = 0;
    ListNode* fast = pHead;
    ListNode* slow = pHead;

    //快指针先走k步
    for(i = 0; i < k; i++)
    {
        //判断链表是否足够长
        if(fast == NULL && i != k - 2)
        {
            return NULL;
        }
        fast = fast->next;
    }

    //快慢指针同时前行，它们之间的距离恒为k
    while(fast != NULL)
    {
        fast = fast->next;
        slow = slow->next;
    }

    return slow;
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    struct ListNode* p1=pHead;
    int ListNum=0, i=0;
    while(p1 != NULL) {
        p1 = p1->next;
        ListNum++;
    }
    if(k>ListNum)
        return NULL;
    p1=pHead;
    while(i<ListNum-k) {
        p1 = p1->next;
        i++;
    }
    return p1;
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    //快慢指针
    struct ListNode* fast = pHead; 
    struct ListNode* slow = pHead;
    int i=0;

    for (i=0; i<k; ++i) //快指针先走k步
    {
        if(fast==NULL) return NULL; //链表长度小于k，返回空指针
        fast = fast->next;
    }

    while (fast!=NULL) //快指针到链表末尾，慢指针到想要的节点位置
    {
        fast = fast->next;
        slow = slow->next;
    }

    return slow;
}

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param pHead ListNode类 
 * @param k int整型 
 * @return ListNode类
 */
struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    // write code here
    int iNum = 0;
    struct ListNode* ptr = pHead;

    while (ptr) {
        iNum++; ptr = ptr->next;
    }

    if (iNum < k) {
        return  NULL;
    }else{
        ptr = pHead;
        int i = iNum - k;
        while (i--) {
            ptr = ptr->next;
        }
        return  ptr;
    }
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) 
{
    if(!pHead)
    {
        return NULL;
    }
    struct ListNode *p = pHead;
    struct ListNode *q = pHead;
    while(k--)
    {
        q = q->next;
        if(!q && k)
        {
            p = NULL;
            break;
        }
    }
    while(q)
    {
        p = p->next;
        q = q->next;
    }
    return p;
    // write code here
}

双指针法进阶解法
struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    // write code here
    if(pHead==NULL||k==0) return 0;   //空链表和倒数第0个节点都返回0
    struct ListNode *p=pHead,*q=pHead;   //双指针法，定义两个链表类型的指针，达到进阶的空间复杂度O（1）  
    for(int i=1;i<k;i++){                 //for循环让p和q的距离保持为k
        q=q->next;
        if(q==NULL) return 0;            //如果链表长度不够k，则返回0
    }
    while(q->next!=NULL){             //p和q同步往后走，让q指向最后一个节点，p则为倒数第k个节点
        p=p->next;
        q=q->next;
    }
    return p;                      //返回p即可
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    int len = 0, pos, i;
    struct ListNode* c = pHead;
    while(c) {
        len++;
        c = c->next;
    }
    if(k > len) return NULL;
    else {
        pos = len - k;
        c = pHead;
    }
    for(i = 0; i< pos; i++) {
        c = c->next;
    }
    return c;
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    // write code here
    struct ListNode*p0;
    p0=pHead;
    int n=0;
    while(p0!=NULL){
        p0=p0->next;//指向结点的最后一个，直到为空
        n++;//计算结点总数
    }
    if(n<k){//返回的结点必须小于总结点数
        return NULL;
    }
    p0=pHead;//p0重新指向结点头
    for(int i=0;i<(n-k);i++)//结点总数（5）-返回第几个结点（2）=从第（3）个结点开始
    {
        p0=p0->next;
    }
    return p0;
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) 
{
    // write code here
    struct ListNode* tail=pHead;
    int count=0;
    while(tail)
    {
        tail=tail->next;
        count++;
    }
    struct ListNode* start=pHead;
    if(k>count)
    {
        return NULL;
    }
    for(int i=0;i<count-k;i++)
    {
        start=start->next;
    }
    return start;
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    if(pHead == NULL) return pHead;
    struct ListNode *p = pHead,*pn = pHead;
    for(int i = 0;i<k;i++){
        if(pn == NULL) return pn;
        pn = pn->next;
    }
    while(pn){
        p = p->next;
        pn = pn->next;
    }
    return p;
    // write code here
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    //快慢指针干一波，这次不是1、2，1、2的走，而是快先走，然后快慢一起走
    struct ListNode* slow = pHead, * fast = pHead;
    
    while(fast && k)//快指针先走k步
        {
            fast = fast->next;
            k--;
        }
    if(!fast && k)//如果fast已经空，k不等0，那么k长度大于链表，返回null
        return NULL;
    
    while(fast)//快慢指针一起走，当快指针走向空，slow当前就是k的位置
    {
        slow = slow->next;
        fast = fast->next;
    }
    return slow;//假设k=0，到这一步，slow也是指向空
}

struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    // write code here
    struct ListNode *cur = pHead;
    struct ListNode *pre = pHead;
    int loop = 0;
    for (loop = 0; cur && loop < k; loop++) {
        cur = cur->next;
    }
    if (loop < k) {
        return NULL;
    }
    while (cur) {
        cur = cur->next;
        pre = pre->next;
    }
    return pre;
}