训练营第四天| 24. 两两交换链表中的节点 ，19.删除链表的倒数第N个节点，面试题 02.07. 链表相交，142.环形链表II

一、24. 两两交换链表中的节点，力扣题目链接

        1.1 题目的第一想法

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *vp = new ListNode(0);
        vp->next=head;
        ListNode *cur=vp;
        while(cur)
        {
            ListNode *next1=cur->next;   //存储原来需要遍历的下一个,存储节点1
            ListNode *next2=cur->next->next->next; //存储节点3
            
            cur->next=cur->next->next;      //虚拟头节点->2
            cur->next->next=next1;          //2->1
            cur->next->next->next=next2;    //1->3
            
            cur = next2; 
        }
        return vp->next;
    }
};

        双指针+虚拟头节点。

        1.2 看完代码随想录之后的想法，代码随想录

        1)while循环的条件有问题，应该为

while(cur->next != nullptr && cur->next->next != nullptr)

        2）最开始有点纠结cur->next=cur->next->next;（即虚拟右节点->2），之后是否会导致节点3变为cur->next->next。其实3和1的指针都被存储起来了，不用考虑。

        3）最后cur更新应该为cur = cur->next->next，即下一个节点的前一个节点。

        4）return应该为vp->next,最开始写错了。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *vp = new ListNode(0);
        vp->next=head;
        ListNode *cur=vp;
        while(cur->next && cur->next->next)
        {
            ListNode *next1=cur->next;   //存储原来需要遍历的下一个,存储节点1
            ListNode *next2=cur->next->next->next; //存储节点3
            
            cur->next=cur->next->next;      //虚拟右节点->2
            cur->next->next=next1;    //2->1
            cur->next->next->next=next2;   //1->3
            
            cur = cur->next->next;
        }
        return vp->next;
    }
};

二、19.删除链表的倒数第N个节点，力扣题目链接

        2.1 题目的第一想法

        1)使用虚拟头节点，主要是为了应对删除原本的头节点；

        2）两次遍历。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* vp=new ListNode(0);
        vp->next=head;
        ListNode* cur=vp;
        int count=0;
        while(cur->next!=nullptr)
        {
            count++;
            cur=cur->next;
        }
        cur=vp;
        for(int i=0;i<count-n;i++)
        {
            cur=cur->next;
        }
        cur->next=cur->next->next;
        return vp->next;
    }
};

        2.2 看完代码随想录之后的想法，代码随想录

        1）没想到用快慢指针：让快指针先走n+1步之中，快慢指针同时移动，两者差n+1，当快指针指到最后的null时，慢指针指到了倒出第n和节点的前一个节点，方便删除第n个节点。

        2)fast先走n步方式为

 while(n-- && fast)
        {
            fast=fast->next;
        }

三、面试题 02.07. 链表相交，力扣题目链接

        3.1 题目的第一想法

        没有思路。。。。

        3.1.1 力扣解答1，哈希set+遍历

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        unordered_set<ListNode *> s;
        while (curA != NULL) { //首先遍历链表headA，将其中的每个节点加入哈希集合中
            s.insert(curA);
            curA = curA->next;
        }
        while (curB!= NULL) { //链表headB中遍历到的第一个在哈希集合中的节点就是相交的节点
            if(s.count(curB)) //用set.count(value)判断是否在  
            {
                return curB;
            }
            else
                curB = curB->next;
        }
        return nullptr;
    }
};

       3.1.2 力扣解答2，双指针+同时遍历两次

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *A = headA, *B = headB;
        //若两链表有公共尾部 (即c > 0) ：指针A ,B同时指向「第一个公共节点」node；
        //若两链表 无 公共尾部 (即 c = 0c=0 ) ：指针 A , B 同时指向 nullnull 
        while (A != B) {            
            if(A!=nullptr)
            {
                A=A->next;
            }
            else{
                A=headB;
            }
            //以上表示指针 A 先遍历完链表 headA ，再开始遍历链表 headB ，当走到 node 时，共走步数为：a + (b - c)
            if(B!=nullptr)
            {
                B=B->next;
            }
            else{
                B=headA;
            }
            //以上表示，指针 B 先遍历完链表 headB ，再开始遍历链表 headA ，当走到 node 时，共走步数为：b + (a - c)

        }
        return A;   
    }
};

        3.2 看完代码随想录之后的想法，代码随想录

        先求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

        

        此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。否则循环退出返回空指针。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

四、142.环形链表II，力扣题目链接

        4.1 题目的第一想法

        接触过类似的题，双指针

        4.2 看完代码随想录之后的想法，代码随想录

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};