代码随想录算法训练营第四天｜● 24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II

状态：坐了一天飞机的非常美丽的精神状态。元宵节快乐！

时长：懒得记了嘻嘻，今天先这样

 24. 两两交换链表中的节点 

用虚拟头结点，这样会方便很多。 

本题链表操作就比较复杂了，建议大家先看视频，视频里我讲解了注意事项，为什么需要temp保存临时节点。

题目链接/文章讲解/视频讲解： 代码随想录

1. 注意奇数个数和偶数个数。

2. 注意while 判断的顺序，先执行cur->next,再cur->next->next，

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* cur = dummyhead;
        //这道题要考虑到cur->next->next->next，一共要考虑四个节点
        while(cur->next!=nullptr&&cur->next->next!=nullptr){
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;
            cur->next = cur->next->next;
            cur->next->next = tmp;
            tmp->next = tmp1;
            cur = cur->next->next;
        }
        return dummyhead->next;
    }
};

链表操作挺绕到，画图画箭头清洗一点也好做，

注意cur->next是一般有意义的节点（好的总结不太好，之后再想想）

 19.删除链表的倒数第N个节点  

双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向 第N个节点的前一个节点，建议先看视频。

题目链接/文章讲解/视频讲解：代码随想录

双指针AC，第一次有思路了妙哉！

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* fast = head;
        ListNode* slow = head;
        for(int i = 0; i< n; i++){
            fast = fast->next;
        }
        while(fast!=nullptr && fast->next!=nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        //[1]
        if(slow->next == nullptr){
            return nullptr;
        }
        //delete head
        if(fast==nullptr){
            return head->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        tmp->next = NULL;
        delete tmp;
        return head;
    }
};

160.  面试题 02.07. 链表相交  

本题没有视频讲解，大家注意 数值相同，不代表指针相同。

题目链接/文章讲解：代码随想录

这道题重点在于审题时明白比较的是指针。

对齐链表，结束, AC.

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lengthA = 0;
        int lengthB = 0;
        ListNode* cur = headA;
        while(cur!=NULL){
            lengthA++;
            cur = cur->next;
        }
        cur = headB;
        while(cur!=NULL){
            lengthB++;
            cur = cur->next;
        }
        ListNode* first = headA;
        ListNode* second = headB;
        if(lengthA >= lengthB){
            for(int i = 0; i < (lengthA-lengthB); i++){
                first = first->next;
            }
        }else{
            for(int i = 0; i < (lengthB-lengthA); i++){
                second = second->next;
            }
        }
        while((first!=second)&&(first!=nullptr)&&(second!=nullptr)){
            first = first->next;
            second = second->next;
        }
        if((first == nullptr)&&(second == nullptr)){
            return NULL;
        }else{
            return first;
        }
    }
};

 142.环形链表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;

        while(fast!=NULL && fast->next!=nullptr){
            slow = slow->next;
            fast = fast->next->next;
            if(fast==slow){
                ListNode* start = head;
                while(start!=slow){
                    slow = slow->next;
                    start = start->next;
                }
                return slow;
            }
        }
        return NULL;
    }
};