[leetcode-160]Intersection of Two Linked Lists(c)

问题描述：
Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

A: a1 → a2
↘
c1 → c2 → c3
↗
B: b1 → b2 → b3
begin to intersect at node c1.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Your code should preferably run in O(n) time and use only O(1) memory.
Credits:
Special thanks to @stellari for adding this problem and creating all test cases.

分析：该题虽然为easy，却一点都不easy，首先是不知道交接点之前两个链表有多少元素，
起初我是想能不能倒序查找，但是那样一来的话，就要改变链表结构，而且改动很大。然后看着看着，越看越像一个环，然后我试着把尾部和头部连接起来，突然发现这就变成了一个环，而整个问题就变成了之前做的一个问题。真是柳暗花明又一村啊。

代码如下：32ms

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if(!headA || !headB)
        return NULL;

    //构成一个环    
    struct ListNode *curA = headA;
    struct ListNode *tail;
    while(curA->next){
        curA = curA->next;
    }
    curA->next = headA;

    struct ListNode *slow = headB,*fast = headB;//构成快慢指针

    while(fast!=NULL){
       if(slow) slow = slow->next;
       if(fast) fast = fast->next;
       if(fast) fast = fast->next;

       if(slow == fast)//相遇
            break;
    }
    if(!fast){
        curA->next = NULL;
        return NULL;
    }

    fast = headB;
    while(fast!=slow){
        fast = fast->next;
        slow = slow->next;
    }

    curA->next = NULL;
    return fast;
}

---

在这又看了网友的介绍，发现也很巧妙，大致思路是：整个链表分为连接前和连接后，因为连接后长度相等，那么交接前的长度差就等于整个链表的长度差，那么一来，只要让两个指针保持一定距离，然后同时移动就能找到交接点了。

代码如下：32ms

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if(!headA || !headB)
        return NULL;
    struct ListNode* tmpA = headA;
    struct ListNode* tmpB = headB;
    int lengthA = 0;
    int lengthB = 0;
    while(tmpA){
        lengthA++;
        tmpA = tmpA->next;
    }
    while(tmpB){
        lengthB++;
        tmpB = tmpB->next;
    }
    if(tmpA!=tmpB)
        return NULL;

    int offset = lengthB-lengthA;
    tmpA = headA;tmpB = headB;
    if(offset>0){
        while(offset--!=0)
            tmpB = tmpB->next;
    }else{
        while(offset++!=0)
            tmpA = tmpA->next;
    }
    while(tmpA!=tmpB){
        tmpA = tmpA->next;
        tmpB = tmpB->next;
    }
    return tmpA;
}