代码随想录Day4 | 24. 两两交换链表中的节点 、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交 、142.环形链表II

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

这道题目的要把握两个要点，1：要设置虚拟头节点，这样能够使思路更加简洁，不需要特殊处理头节点，2：要在交换的时候把保存后面的节点，否则在交换完就无法链接到后面的节点了

ListNode* dummy = new ListNode(0);
dummy->next = head;

ListNode* tmp = cur->next->next;

交换时的具体步骤如下：

详细代码如下：

/**
 * 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* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* pre=dummy, *cur=head;
        while(cur&&cur->next)
        {
            ListNode* tmp = cur->next->next;
            pre->next=cur->next;
            cur->next->next=cur;
            cur->next = tmp;
            pre = cur;
            cur=tmp;
        }
        return dummy->next;

    }
};

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

这道题目需要双指针，一个慢一个快，两个指针之间的差距是n，这样当快指针到最后一个元素，slow正好到倒数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) {
        if(head==nullptr) return nullptr;
        ListNode* dummy = new ListNode(0);
        dummy->next=head;
        ListNode* slow=dummy,*fast=dummy;
        int i=0;
        while(i<n)
        {
            fast=fast->next;
            i++;
        }
        while(fast&&fast->next)
        {
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;
        return dummy->next;

    }
};

面试题 02.07. 链表相交

这道题目，之前有做过，思路就是交叉走两个链表，第一次相遇的地方就是相交的节点：

自己写了代码，详细代码如下：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode*n1 = headA,*n2=headB;
        if(n1==nullptr||n2==nullptr){return nullptr;}
        while(n1!=n2)
        {
            if(n1&&n2)
            {
                n1=n1->next;
                n2=n2->next;
            }
            else if(n1==nullptr&&n2==nullptr)
            {
                n1=headB;
                n2=headA;
            }
            else if(n1==nullptr)
            {
                n1=headB;
                n2=n2->next;
            }
            else
            {
                n1=n1->next;
                n2=headA;
            }
        }
        return n1;
        
    }
};

但是在看了大神的思路之后，发现自己写的代码太不简洁，可以用三目运算符来精简上面的代码：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode*n1 = headA,*n2=headB;
        while(n1!=n2)
        {
            n1 = (n1==nullptr)?headB:n1->next;
            n2 = (n2==nullptr)?headA:n2->next;
        }
        return n1;
        
    }
};

142.环形链表II 

这道题目的思路是快慢指针，快指针每次两步，慢指针每次一步，两个指针相遇的节点为node，（两个指针一定会相遇，这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的）然后其中一个从头开始，另一个指针从node节点开始，相遇的地方为环的入口，具体的推导可以看代码随想录。

详细代码如下：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* slow = head, *fast=head;
        while(fast&&fast->next)
        {
            fast=fast->next->next;
            slow=slow->next;
            if(fast==slow) break;
        }
        if(fast==NULL||fast->next==NULL) return nullptr;
        slow = head;
        int i=0;
        while(slow!=fast)
        {
            slow=slow->next;
            fast=fast->next;
            i++;
        }
        return slow;
        
    }
};

本次学习时间2.5小时