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

Day 04

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

题目最好是用虚拟头结点，好处就是不用每次都单独处理头结点（这里指的是找到新链表的头结点，保证最后可以输出），这个有很多办法，反正只需要使用while做循环条件保证可以遍历链表同时可以调换顺序即可。

下面代码和代码随想录有点区别（关于处理换位置的顺序）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* _dummyhead=new ListNode(0);
        _dummyhead->next=head;
        ListNode* pre=head;
        ListNode* tmp=_dummyhead;
        while(pre!=nullptr && pre->next!=nullptr){
            ListNode* cur=pre->next;
            pre->next=cur->next;
            cur->next=pre;
            tmp->next=cur;
            tmp=tmp->next->next;
            pre=pre->next;
            cur=nullptr;
        }
        return _dummyhead->next;
    }
};

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

我看到这题想的是判断这个链表有多长，通过while找出_size的长度，然后通过_size-n的方式找到应该遍历多少次。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* _dummyhead=new ListNode(0);
        _dummyhead->next=head;
        int _size=0;
        ListNode* cur=_dummyhead;
        while(cur->next!=nullptr){
            cur=cur->next;
            _size++;
        }
        int index=_size-n;
        ListNode* fast=_dummyhead;
        while(index--){
            fast=fast->next;
        }
        fast->next=fast->next->next;
        return _dummyhead->next;
    }

};

代码随想录中则是使用两个指针，利用其相对位置找出倒数第n个的位置。需要注意的是，里面用的是fast！=nullptr，所以当while循环结束fast指向null，所以这时候slow正好指向要删除的位置（也就是虽然fast通过循环向后移动n格，按理说正好，但是要考虑fast最后指向null，那么其实是少一格的）所以还要再加一步fast=fast->next，保证slow指向要删除的前一个。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* _dummthead=new ListNode(0);
        _dummthead->next=head;
        ListNode* fast=_dummthead;
        ListNode* slow=_dummthead;
        while(n--&&fast!=nullptr){
            fast=fast->next;
        }
        fast=fast->next;
        while(fast!=nullptr){
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;
        return _dummthead->next;
    }
};

这个题我是在while循环卡住了，，当while（n--）时，是判断n是否为0的，

例如n为2，其实是执行2次，

首先n=2！=0，进入循环，n=1 ；

然后n=1！=0，进入循环，n=0；

最后n=0不满足，直接退出循环；

面试题 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* curA=headA;
        ListNode* curB=headB;
        int lenA=0;
        int lenB=0;
        while(curA!=nullptr){
            curA=curA->next;
            lenA++;
        }
        while(curB!=nullptr){
            curB=curB->next;
            lenB++;
        }
        curA=headA;
        curB=headB;

        if(lenB>lenA){
            swap(lenB,lenA);
            swap(curB,curA);
        }
        int gap=lenA-lenB;
        while(gap--){
            curA=curA->next;
        }
        while(curA!=curB){
            curA=curA->next;
            curB=curB->next;
        }
        return curA;
    }
};

142.环形链表II 

本题需要使用一些数学思路推导一下，

判断是否有环的方法：设置一个slow每次走一步，设置一个fast每次走两步，如果有环，那么一定可以相遇，可以理解为fast首先入环，然后等slow入环之后就相当于fast追赶slow，每次靠近一步。那么一定可以相遇。

/**
 * 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!=nullptr&&fast->next!=nullptr){
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow){
                ListNode* index=head;
                while(index!=fast){
                    index=index->next;
                    fast=fast->next;
                }
                return index;
            }
        }
        return NULL;
        
    }
};

代码中的思路很巧妙，如果有环在里面直接输出，没环退出while循环直接输出NULL

链表总结

链表这里其实就是遍历的问题，还有一般在有修改链表操作的时候都是加上虚拟头结点更好用。

除此之外，学会了一个debug的方法，可以在力扣里面直接cout出中间值（也就是说力扣里面可以有标准输出），看看哪一步出错。