Leetcode Intersection of Two Linked Lists

/**
 * 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) {
        int lena = count(headA);
        int lenb = count(headB);
        int diff = 0;
        ListNode* longer = NULL;
        ListNode* shorter= NULL;
        if (lena > lenb) {
            diff = lena - lenb;
            longer = headA;
            shorter= headB;
        } else {
            diff = lenb - lena;
            longer = headB;
            shorter= headA;
        }
        longer = forward(longer, diff);
        
        while (longer != shorter) {
            longer = forward(longer, 1);
            shorter= forward(shorter, 1);
        }
        return longer;
    }
    ListNode* forward(ListNode* head, int step) {
        while(head != NULL) {
            if (step-- <= 0) {
                break;
            }
            head = head->next;
        }
        return head;
    }
    int count(ListNode* head) {
        int res = 0;
        while (head != NULL) {
            head = head->next;
            res++;
        }
        return res;
    }
};

Leetcode 也有可视化了，越来越高端了

第二轮：

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.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 // 20:08
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* cura = headA;
        ListNode* curb = headB;
        
        int na = 0, nb = 0;
        
        while (cura != NULL) {
            na++;
            cura = cura->next;
        }
        
        while (curb != NULL) {
            nb++;
            curb = curb->next;
        }
        ListNode* prewalk = NULL;
        
        int diff = 0;
        if (na > nb) {
            prewalk = headA;
            diff = na - nb;    
        } else if (na < nb) {
            prewalk = headB;
            diff = nb - na;
        }
        while (diff--) {
            prewalk = prewalk->next;
        }
        
        cura = headA;
        curb = headB;
        
        if (na > nb) {
            cura = prewalk;
        } else if (na < nb){
            curb = prewalk;
        }
        
        while (cura != curb) {
            cura = cura->next;
            curb = curb->next;
        }
        return cura;
    }
};