代码随想录算法训练营周日（补Day04）| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

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

题目链接/文章讲解/视频讲解：  代码随想录

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

输入：head = [1,2,3,4]
输出：[2,1,4,3]

输入：head = []
输出：[]

输入：head = [1]
输出：[1] 

方法一：迭代 

/**
 * 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); //新建虚拟节点
        ListNode* cur = dummyHead;
        dummyHead->next = head; //虚拟节点指向头节点
        //while的终止条件分别为奇数，偶数的情况
        while(cur->next != NULL && cur->next->next != NULL){
            //保留指针，否则更改指向后找不到
            ListNode* temp = cur->next; 
            ListNode* temp1 = cur->next->next->next;
            
            //三者是循序渐进，一个个指过去，以第一次交换为例
            cur->next = cur->next->next;
            cur->next->next = temp; //前一句把指向1的指针改变了，现在用temp来代替
            cur->next->next->next = tmp1; //前一句把指向3的指针改变了，现在用temp来代替

            cur = cur->next->next; //这样就保持了算法的一致性
        }
        return dummyHead->next;
    }
};

复杂度分析 

• 时间复杂度：O(n)
• 空间复杂度：O(1)

错误： 

• cur->next已经把指针指向头改变了，不能按照原来的指向思考，就顺着next一步一步走就行
• temp都是临时指针，用于存储节点，cur才是改变链表走向的 

方法二：递归

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode* newHead = head->next;
        head->next = swapPairs(newHead->next);
        newHead->next = head;
        return newHead;
    }
};

复杂度分析

时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。

空间复杂度：O(n)，其中 n 是链表的节点数量。空间复杂度主要取决于递归调用的栈空间。

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

题目链接/文章讲解/视频讲解： 代码随想录

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

输入：head = [1], n = 1
输出：[]

输入：head = [1,2], n = 1
输出：[1]

思路：

• 双指针，虚拟头节点 
• 快指针走了n步后，慢指针跟着快指针一起走，直到快指针指向NULL，此时慢指针肯定指向倒数第n个节点
• 由于快慢指针一开始指向的是虚拟头节点，就是head前一个，那么慢指针正好指向要删除节点的前驱节点，使用slow->next = slow->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* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = new ListNode(0);
        ListNode* slow = new ListNode(0);
        fast = dummyHead;
        slow = dummyHead;
        n++; //防止n比链表长度大，fasty已经指向NULL就不能fast = fast->next
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        while(fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* temp = slow->next;
        //要删除哪个元素就找到它的前驱节点把它的指向改变
        slow->next = slow->next->next; //第n个节点就是slow->next
        delete temp;
        return dummyHead->next;
    }
};

复杂度分析

• 时间复杂度：O(n)O(n)，其中 nn 是链表的节点数量。需要对每个节点进行更新指针的操作。

• 空间复杂度：O(1)O(1)。

 

面试题 02.07. 链表相交 

题目链接/文章讲解： 代码随想录

 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

思路： 

• 链表相交后，最终长度相等同时结束，所以要从长度入手，可以使用遍历的方法求链表长度。
• 为了方便计算，令A为较长的链表
• 调整两链表尾部对齐使用长度差，使长链表不断向后遍历

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 

题目链接/文章讲解/视频讲解： 代码随想录

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

思路：

• 使用快慢指针，转化为类似追及问题

数学推导：

slow = x + y  

fast = x + y + n* (y + z)     fast至少走过1环

2*(x + y) = x + y + n * (y + z)         fast总共比slow多走一倍

x + y = n* (y + z)

x = n * (y + z) - y  

x = (n - 1)*(y + z) + z     => n>=1

x = z

/**
 * 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){
            fast = fast->next->next; //快指针每次走两格
            slow = slow->next; //慢指针每次走一格
            if(fast == slow){
                //根据前面的推导y = z,所以要找到入口就是把fast和head同时走直到相遇
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;
            }
        }
        return NULL;
    }
};

复杂度分析

时间复杂度：O(N)，其中 NN 为链表中节点的数目。在最初判断快慢指针是否相遇时，\textit{slow}slow 指针走过的距离不会超过链表的总长度；随后寻找入环点时，走过的距离也不会超过链表的总长度。因此，总的执行时间为 O(N)+O(N)=O(N)O(N)+O(N)=O(N)。

空间复杂度：O(1)。我们只使用了slow,fast,ptr 三个指针。