快慢指针

快慢指针一般用来找到链表的中间节点，就是直接搞两个指针，快指针的移动是慢指针的两倍，那么为什么快慢指针可以找到中间节点，因为假设一个为n的链表，快指针走完慢指针也就是n/2。

具体案例

找链表的中间节点

typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {
    ListNode *lowhead,*fasthead;
    lowhead=fasthead=head;
    //注意一点过要牢记fasthead&&fasthead->next一定不能为空
    while(fasthead&&fasthead->next)
    {
        lowhead=lowhead->next;
        fasthead=fasthead->next->next;
    }
    return lowhead;
}

2.输入一个链表，输出该链表中倒数第k个结点

typedef struct ListNode ListNode;
int kthToLast(struct ListNode* head, int k){
    //可以利用快慢指针的思想让快指针，先移动k个值，然后快慢一起移动
    //当快指针指向空的时候慢指针刚好就是所要查找的位置
       ListNode *fast,*slow;
       fast=slow=head;
       for(int i=0;i<k;i++)
       {
        fast=fast->next;
       }
       while(fast)
       {
        slow=slow->next;
        fast=fast->next;
       }
    return slow->val;
}

 3.相交链表

解析：证明相交链表，首先要对俩表进行遍历然后计算二者的差值让长链表先移动插值个节点，最后保证两个链表遍历到最后时两个元素是否为相同节点。

typedef struct ListNode ListNode;
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    ListNode *L1,*L2;
    L1=headA;
    L2=headB;
    int sizeA=0;
    int sizeB=0;
    while(L1)
    {
        L1=L1->next;
        sizeA++;
    }
     while(L2)
    {
        L2=L2->next;
        sizeB++;
    }
    ListNode *longlist=headA;
    ListNode *shortlist=headB;
    int gap=abs(sizeA-sizeB);
    if(sizeA<sizeB)
    {
        longlist=headB;
        shortlist=headA;
    }
    while(gap--)
        {
            longlist=longlist->next;
        }
     while(longlist&&shortlist)
    {
        if(longlist==shortlist)
        {
            return longlist;
        }
        longlist=longlist->next;
        shortlist=shortlist->next;
    }
    return NULL;
}

4.环行列表（利用快慢指针）

解析如下：利用快慢指针进行判断，只要能证明快慢指针在环中一定会相遇，即可解释这个问题

证明如下：

1.当快指针是慢指针的2倍（这样每次快的比慢的多1），设它相差的距离为N，那么就会出现

N-1,N-2，N-3.....1,0。这样最后还是会出现相遇的情况。

2.当快指针是慢指针的三倍时（这样每次快的比慢的多2，设距离相差为N，那么这时候就要讨论 N的奇偶问题。N为偶数时N-2,N-4,N-6....0, N为奇数时N-2,N-4....1,-1（这种情况就是出现了套圈）。套圈分为两种

 

typedef struct ListNode ListNode;
bool hasCycle(struct ListNode *head) {
    ListNode *fast,*slow;
    fast=slow=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)
        {
            return true;
        }
    }
    return false;
}

 5.环形链表

 

解题思路： 相遇点和头节点到入环的节点距离相同，证明如下：设整个环形为R，快指针：NR+L+x

慢指针：L+X。2（L+X)=NR+L+x-->L+X=NR-->L=NR-X-->L=(N+1)R+R-X;所以推出L==R-X;

typedef struct ListNode ListNode;
struct ListNode *detectCycle(struct ListNode *head) {
    //先找到相遇点，从相遇点向后走
    ListNode *fast,*slow;
    fast=slow=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)
        {
            ListNode *pcur;
            pcur=head;
            while(pcur!=slow)
            {
                pcur=pcur->next;
                slow=slow->next;
            }
            return pcur;
        } 
    }
    return NULL;
}

总结

 快慢指针在数据结构上的用法还是非常的灵活，并且效率还是非常的高效，这些知识还是比较重要的，后续还有会继续更新，最后期待各位大佬的指正。