算法题打卡day4 | 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、160. 链表相交、142.环形链表II

24. 两两交换链表中的节点 - 力扣（LeetCode）

状态：一次提交出现对[]情况的执行错误，简单修改后AC。

 印象中链表操作有一个hard题，这个算是那个的低配版。链表操作相关题目基本是多指针的思路，区别就是指针的数量和前进方式。这道题的数量设置为3，pre、first和second。其中pre代表交换对前面的那个节点，first和second分别代表待交换的第一、二个节点。需要考虑链表个数为偶数和奇数的不同情况，这个可以通过对second的判断得到，还有就是要注意对head为null的特殊情况进行判断。代码如下，时间复杂度。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if(!head){
            return head;
        }
        ListNode* dummyHead = new ListNode();
        dummyHead->next = head;
        ListNode* pre = dummyHead;
        ListNode* first = head;
        ListNode* second = head->next;
        while(second){
            //交换
            ListNode* next = second->next;
            second->next = first;
            first->next = next;
            pre->next = second;

            pre = first;
            first = next;
            if(!next){
                break;
            }
            second = first->next;
        }
        return dummyHead->next;
    }
};

 19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

状态：初见AC。

快慢指针，没什么好说的。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        // 快慢指针的思路，两个间隔为n
        ListNode* dummyHead = new ListNode();
        dummyHead->next = head;
        ListNode* pre = dummyHead;
        ListNode* slow = head;
        ListNode* fast = head;

        while(n--){
            fast = fast->next;
        }

        while(fast){
            pre = slow;
            slow = slow->next;
            fast = fast->next;
        }

        // 删除slow指向的节点
        pre->next = slow->next;
        delete(slow);
        return dummyHead->next;
    }
};

 160. 相交链表 - 力扣（LeetCode）

状态：由于之前做过所以想到了接力遍历对思路，但是没有成功实现。

思路属于做了就会，但是如何让代码精简易懂是个需要持续练习的过程。代码如下，时间复杂的。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        ListNode *pA = headA, *pB = headB;
        while (pA != pB) {//谁先走到末尾，就回到另一个链表起始位置
            pA = pA == nullptr ? headB : pA->next;
            pB = pB == nullptr ? headA : pB->next;
        }
        return pA;
    }
};

142. 环形链表 II - 力扣（LeetCode）

状态：忘记了如何检测入口，需要巩固。

 检测链表是否有环已经可以通过快慢指针实现，原理很简单：快指针相对慢指针是在一步一步接近它，所以有环的话最终一定会在环上相遇。而如何判断入口才是重点，具体见代码中注释，同时也要考虑代码整体逻辑，时间复杂度为。

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        //快慢指针，slow一次走一步，fast一次走两步
        //如果slow==fast!=nullptr，说明有环
        ListNode *slow = head, *fast = head;
        while(fast != nullptr && fast->next != nullptr){
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast){ //有环
                // slow = (x+y+z), fast = x+n(y+z)
                // 2*slow = fast --> x = (n-1)(y+z)+z --> x = z
                // x = 头到入口距离，y = 入口到相遇距离，z = 环上相遇到入口距离
                ListNode* res = head;
                while(res != slow){ //slow此时代表相遇处的节点
                    res = res->next;
                    slow = slow->next;
                }
                return res;
            }
        }
        return nullptr;
    }
};