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

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

1. 题目
   给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
   题目链接：https://leetcode.cn/problems/swap-nodes-in-pairs/

2. 代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode *_head = new ListNode();//虚拟头结点，统一操作
        _head -> next = head;
        //需要用到的指针
        ListNode *prep, *p, *q, *nexq;//p，q为需要交换的两个节点，prep为p的前驱，nexq为q的后继
        prep = _head;
        p = head;
        //遍历
        while(p != nullptr && p -> next != nullptr){//还剩一个的情况不进行操作 
            q = p -> next;
            nexq = q -> next;
            //交换
            prep -> next = q;
            q -> next = p;
            p -> next = nexq;
            //遍历
            prep = p;
            p = nexq;
        }
        head = _head -> next;
        return head;
    }
};

3. 小结
   使用虚拟头结点统一头结点交换的特殊情况，根据交换使用多个指针避免链表出现断链的情况，注意有奇数个结点或偶数个结点的链表在结尾的不同操作。

19 、删除链表的倒数第n个节点

1. 题目
   给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
   题目链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

2. 代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //构建虚拟头结点
        ListNode * _head = new ListNode();
        _head -> next = head;
        //定义需要的指针
        ListNode *p, *q;//p用于指向删除结点的前驱，q用于定位删除的结点
        p = _head;
        q = _head;
        //找到p与q之间的位置关系；
        while(n != 0 && q!= nullptr){
            q = q -> next;
            n--;
        }
        if(q == nullptr) return head;
        //找到目标结点的前驱
        while(q -> next != nullptr){
            p = p -> next;
            q = q -> next;
        }
        //删除操作
        q = p -> next;
        p -> next = q -> next;
        delete q;
        
        head = _head -> next;
        delete _head;
        
        return head;
    }
};

3. 小结
   使用双指针的方法，确定删除的目标结点的前驱与尾结点之间的距离。使用p、q，先将q单独遍历直到p、q之间的距离符合目标结点的前驱与尾结点之间的距离时，将p 、q同时遍历，直到q到达为尾结点时，p在的位置就是目标结点的前驱，此时只需要进行删除操作就可以了。该方法的时间复杂度就为O（n）。需要特别注意若删除的结点是头结点时，可以采用虚拟头结点的方法统一操作。

面试题 02.07. 链表相交

1. 题目
   给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
   题目链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/
2. 代码

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        //相关变量
        int na = 0, nb = 0, n = 0;//na-a链表长度，nb为b链表长度，n为两链表长度差值
        ListNode *pa, *pb;//pa-遍历a链表、pb遍历b链表
        
        //a\b链表空的情况
        if(headA == NULL || headB == NULL) return NULL;

        //其他情况
        pa = headA;
        pb = headB;

        //求链表长度
        while(pa != NULL){
            na++;
            pa = pa -> next;
        }
        while(pb != NULL){
            nb++;
            pb = pb -> next;
        }

        if(na >= nb) n = na - nb;
        else n = nb -na;


        //对齐链表尾
        pa = headA;
        pb = headB;
        while(n != 0){
            if(na > nb) pa = pa -> next;
            else pb = pb -> next;
            n--;
        }

        //遍历找交点
        while(pa != pb && pa != NULL && pb != NULL){
            pa = pa -> next;
            pb = pb -> next;
        }

        //没有交点
        if(pa == NULL || pb == NULL) return NULL;
        else  return pa;

    }
};

3. 小结
   本题思路与上题相似，都是需要对齐队尾元素然后进行遍历找到相同的结点，时间复杂度为o（n）。

142 、环形链表||

1. 题目
   给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
   如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
   不允许修改 链表。
   题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/

2. 代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //相关变量
        ListNode *slow = head;
        ListNode *fast = 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;
    }
};

3. 小结
   使用双指针法，重点理解为何存在环时，fast和slow为何一定在环内相遇，以及一个从相遇点走和一个从头结点走，为何相遇点是环的入口。若存在环，fast永远比slow多走一步，当slow进入环内，fast会以每次一格结点的速度最终追上slow。当slow与fast相遇时，fast的经过的结点数是slow的两倍，也就是说一个从相遇点，一个从头结点以相同速度出发最终会从环的入口开始相遇并同步前进。