5.4刷题（leecode面试题 02.07. 链表相交，leecode142.环形链表II）

leecode面试题 02.07. 链表相交

此题一开始的想法也就是如下想法，朴素版做法。

/**
 * 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) {
        ListNode* dummyNode_A = new ListNode(0);
        dummyNode_A->next = headA;
        ListNode* dummyNode_B = new ListNode(0);
        dummyNode_B->next = headB;
        int sizeA = 0;
        int sizeB = 0;
        ListNode* cur_a = dummyNode_A;
        while(cur_a->next!=nullptr){
            cur_a = cur_a->next;
            sizeA++;
        }

        ListNode* cur_b = dummyNode_B;
        while(cur_b->next!=nullptr){
            cur_b = cur_b->next;
            sizeB++;
        }
        
        //这个做法是让A链表永远是最长的
        ListNode* result = NULL;
        if(sizeA < sizeB){
            swap(dummyNode_A, dummyNode_B);
            swap(sizeA, sizeB);
        }

        int sub = sizeA - sizeB;
        cur_a = dummyNode_A->next;
        cur_b = dummyNode_B->next;
        while(cur_a!=nullptr && sub>0){
            cur_a = cur_a->next;
            sub--;
        }


        while(cur_a != nullptr && cur_b != nullptr){
            if(cur_a == cur_b){
                result = cur_a;
                break;
            }
            else{
                cur_a = cur_a->next;
                cur_b = cur_b->next;
            }
        }
      return result;
    }
};

然后下面再介绍一个在leecode上看到的神仙解法K神解法

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* a = headA;
        ListNode* b = headB;
        while(a != b){
            a = a!=NULL?a->next:headB;
            b = b!=NULL?b->next:headA;
        }
        return a;
    }
};

这种写法简直强无敌，思路就是，让一个指针a先遍历A，再遍历B。让另一个指针b。如果当他俩没有公共节点的时候，遍历完都会指向null的位置，那么返回null。如果两个链表有一个公共节点那么他们一定会走到那里，总之细节点链接看k神解题，只能说真的牛逼！

leecode142. 环形链表 II

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //定义快慢指针，快指针一下子走两个，慢指针一下子走一个
        ListNode* fast = head;
        ListNode* slow = head;
        //因为快指针相对于慢指针一下子是走一个，所以两个指针肯定可以相遇如果有环的话
        //但是如果没有环的话，两个指针都会指向null
        while(fast!=NULL && fast->next!=NULL){
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow){
                ListNode* index_nei = fast;
                ListNode* index_wai = head;
                //这里建议借鉴一下ka哥的代码随想录，我觉得他讲的思路很好
                while(index_nei!=index_wai){
                    index_nei = index_nei->next;
                    index_wai = index_wai->next;
                }
                return index_wai;
            }
        }

        return NULL;

        

    }
};

这道题有一个比较经典的思路，是借鉴代码随想录上面的。我认为比较好理解，而且容易看懂。现在给大家把链接贴上来。代码随想录解题思路