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

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

本题拿到手，要注意题目要求的是两两交换其中相邻的节点，只能进行节点交换

那么我们应该如何应对？

首先看到这题，就可以发现这是一道模拟题，正常模拟就行。

那么针对本题已经确认要以模拟的方式来写时，我们有没有更好的方法让我们的模拟更简单呢？

我认为设置虚拟头结点来解决这道题目将会是一个不错的选择，不然对于头结点而言，还要单独处理，就很麻烦。。。

我们设置一个虚拟头结点，让这个虚拟头结点指向真正的头结点，然后就可以模拟了；

模拟过程

        1.先让虚拟头结点（我们标记它为0号节点）指向2号节点

        (因为此时0号节点与1号节点断开了连接，我们需要这之前，先定义一个tmp来存放这个断开了的1号节点)

        2.然后让二号节点指向1号节点

        (又因为此时2号节点与3号节点断开了连接，我们需要这之前，再定义一个tmp1来存放这个断开了的3号节点)

        3.然后让1号节点指向3号节点

        4.最后我们调整下一组0号节点的位置，使其向后移动2个节点

        这样我们就完成了一次循环

整体代码如下

/**
 * 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* fake_head=new ListNode(0);
        fake_head->next=head;//定义虚拟头结点
        ListNode* cur=fake_head;
        while(cur->next!=NULL&&cur->next->next!=NULL){
            ListNode* tmp=cur->next;//存放断开的1号节点
            ListNode* tmp1=cur->next->next->next;//存放断开的三号节点
            cur->next=cur->next->next;//0号节点指向2号节点
            cur->next->next=tmp;//2号节点指向提前存放好的1号节点
            cur->next->next->next=tmp1;//1号节点指向提前存放好的3号节点
            
            cur=cur->next->next;//调整一组循环中0号节点的位置
        }
        head=fake_head->next;
        delete fake_head;//虽然不手动释放虚拟节点也能AC，但是养成好习惯准没错
        return head;
    }
};

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

对于本题，我拿到手的第一想法 就是设置一个指针，走到链表的底部，再往回倒退，但是很显然，这是顺序表，我们无法倒退，那我们又应该如何应对？

那么我的想法是再设置一个指针，总共俩个指针，分别命名为快/慢指针，我们可以让快指针先往下走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* fake_head=new ListNode(0);
        fake_head->next=head;
        //设置快慢指针
        ListNode* fast=fake_head;
        ListNode* slow=fake_head;
        //让慢指针先走n个节点
        while(n--&&fast->next!=NULL){
            fast=fast->next;
        }
        //让快慢指针同时走
        while(fast->next!=NULL){
            fast=fast->next;
            slow=slow->next;
        }
        //删除对应的指针
        slow->next=slow->next->next;
        return fake_head->next;

    }
};

面试题 02.07. 链表相交

看到这题题目，我是没什么思路的，后来参考了代码随想录 (programmercarl.com)的文章，我才有所启发，大概的思路就是将两条相交的链表拉直，靠右对齐，然后对比，如果两个节点相等，即可得出交点的位置（注意，判断条件是两个节点相等，而非两个节点的值相等）

具体代码如下：

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

这道题目考查了关于链表和数学的操作，难度还是有一点的

那么拿到这个题目，我们需要判断两个点

        1.判断链表是否有环？

        2.判断环的入口在哪？

 1.判断链表是否有环？

        设置两个指针（快慢指针），快指针的移动速度为一次2个节点，慢指针的移动速度为一次1个节点，那么他们的相对移动速度就是1个节点，因此当此链表为环形链表时，快指针会先进入环中，然后继续行走，终会与进入环中的慢指针相遇（因为两个指针的相对移动速度为1，可以理解为一个指针动，一个指针不动，而且又由于他们的相对移动速度是1，所以也不会存在有快指针跳过慢指针运动而永不相遇的情况）

2.如果有环，那么如何判断环的入口在哪？

从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点

具体代码如下

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