LeetCode——Intersection of Two Linked Lists

LeetCode——Intersection of Two Linked Lists

# 160

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.

这一题的目的是找出两个链表的相交结点。一开始思路是利用两个指针去遍历两个链表，但是这样每次走相同的步数，如果两个链表长度不一样，是没办法比较到同一结点的。所以为了解决这个问题，想到了先求两个链表的长度差，让长链表的指针先走到对应的位置，然后两个指针一起走。

• C++

/**
 * 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 lenA = getlength(headA);
        int lenB = getlength(headB);
        if(lenA > lenB) {
            for(int i = 0;i < lenA - lenB;i++) {
                headA = headA -> next;
            }
        }
        else {
            for(int i = 0;i < lenB - lenA;i++) {
                headB = headB -> next;
            }
        }
        while(headA != NULL && headB != NULL) {
            if(headA == headB) {
                return headA;
            }
            else if(headA != headB) {
                headA = headA -> next;
                headB = headB -> next;
            }
        }
       return NULL; 
    }
    int getlength(ListNode *head) {
        int len = 0;
        while(head != NULL) {
            len++;
            head = head -> next;
        }
        return len;
    }
};

还有一种思路，定义两个指针，每个都从头遍历，到了链表终点就从另一个链表初始点开始遍历。两个链表如果相交，肯定会在相交点相遇，因为路程是相同的。如果不相交，两个指针都会在彼此链表空结点结束。

• C++

/**
 * 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 || !headB) return NULL;
        ListNode *a = headA, *b = headB;
        while (a != b) {
            a = a ? a->next : headB;
            b = b ? b->next : headA;
        }
        return a;
    }
};