LeetCode探索之旅（37）-160两个链表的交汇点

今天继续刷LeetCode，第160题，求两个链表的交汇节点。

分析：
既然是交汇点，那么应该是从后往前存在一定长度的相同节点，类似于Y的形状，但是链表的特点是不可以从后往前遍历，那么就只有从前往后遍历。首先分别计算出两个链表的长度，然后求出长度差，然后长的一个链表先从前往后遍历一个长度差的长度，然后两个链表继续同时向后遍历，直到两个链表的节点相等，就是交汇节点。

问题：
1、特殊情况，链表为空的时候；
2、求链表长度；

附上代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA==NULL||headB==NULL)
            return NULL;
        int length1=0;
        int length2=0;
        ListNode* A=headA;
        ListNode* B=headB;
        while(A!=NULL)
        {
            length1++;
            A=A->next;
        }
        while(B!=NULL)
        {
            length2++;
            B=B->next;
        }
        int s;
        if(length1>length2)
        {
            s=length1-length2;
            for(int i=0;i<s;i++)
            {
                if(headA==NULL)
                    return NULL;
                headA=headA->next;
            }
            while(headA!=headB)
            {
                
                headA=headA->next;
                headB=headB->next;
                if(headA==NULL&&headB==NULL)
                    return NULL;
            }
            return headA;
        }
        else
        {
            s=length2-length1;
            for(int i=0;i<s;i++)
            {
                if(headB==NULL)
                    return NULL;
                headB=headB->next;   
            }
            while(headA!=headB)
            {
                
                headA=headA->next;
                headB=headB->next;
                if(headA==NULL&&headB==NULL)
                    return NULL;
            }
            return headB;
        }

    }
};

优化后的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA==NULL||headB==NULL)
            return NULL;
        int length1=length(headA);
        int length2=length(headB);
        int s=length1-length2;
        if(s>0)
            return intersection(headA,headB,s);
        else
            return intersection(headB,headA,-s);

    }
    ListNode* intersection(ListNode *headA,ListNode *headB,int s)
    {
        while(s--)
        {
            headA=headA->next;
        }
        while(headA!=headB)
        {
            headA=headA->next;
            headB=headB->next;
            if(headA==NULL&&headB==NULL)
                return NULL;
        }
        return headA;
    }
    int length(ListNode * head)
    {
        int s=0;
        while(head!=NULL)
        {
            s++;
            head=head->next;
        }
        return s;
    }
};

另一个方式：
可以两个链表同时往后遍历，当一个链表遍历完所有节点后，就跳到另外一个链表的头节点开始继续往后遍历，当两个指针相遇的时候，所指节点就是交汇节点。