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

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

 力扣题目链接

 卡尔哥讲解链接

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

示例1： 

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

输出：[2,1,4,3] 

示例2：

输入：head = []

输出：[]

思路：通过改变链表节点中的next指针指向实现交换节点。注意在改变next指向之前，先临时保存next指向的节点，否则next改变指向后，就找不到原来所指向的节点 了。

另外对链表进行插入，删除操作时，需要知道待插入或删除节点的上一个节点，使用虚拟头节点可不用单独处理待操作节点为头节点情况。

注意while循环的判断条件（考虑链表节点数为偶数、奇数的情况），删除节点后记得释放内存

c++ 代码如下： 

/**
 * 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);//设置虚拟头结点
        dummyHead->next = head;//虚拟头结点指向链表的真实头结点
        ListNode* cur = dummyHead;
        while(cur->next !=nullptr && cur->next->next !=nullptr) {//先判断cur->next !=nullptr，防止越界
            //改变指针指向前，先保存原指针指向的节点
            ListNode* temp = cur->next;//记录临时节点
            ListNode* temp1 = cur->next->next->next;//记录临时节点
            
            //开始改变指针指向，实现交换链表节点
            cur->next = cur->next->next;
            cur->next->next = temp;
            cur->next->next->next = temp1;

            cur = cur->next->next;//cur后移动两位，准备下一轮交换
        }
        return dummyHead->next;
    }
};

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

 力扣题目链接

 卡尔哥讲解链接

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

 示例1：

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

输出：[1,2,3,5]面试题 02.07. 链表相交 

 思路：双指针的经典应用，如果要删去倒数第n个节点，让fast移动n步，然后让fast和slow同步移动，直达fast指向链表尾，slow就指向待删除的节点。

为方便删除操作，1、fast指针应当先走n+1步，然后再同时移动fast和slow，当fast指向链表尾时，slow指针恰好指向待删除节点的上一个节点；2、使用虚拟头节点，当要删除的节点恰好为实际头节点时，不再需要单独处理。

C++代码如下：

/**
 * 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 = dummyHead;
        ListNode* slow = dummyHead;
        
        while(n-- && fast->next != nullptr) {
            fast = fast->next;
        }
        fast = fast->next;//fast再往前1步，当fast==nullptr时，slow指向待删除节点的上一个节点

        while(fast != nullptr) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* temp = slow->next;
        slow->next = temp->next;
        delete  temp;//释放被删除节点的内存空间

        return dummyHead->next;
    }
};

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

面试题 02.07. 链表相

力扣题目链接

卡尔哥讲解链接

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

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 

思路：简单来说，就是求两个链表点交点点的指针。 注意，交点不是数值相关，而是指针相关。

1. 设置两个临时指针curA,curB分别指向headA,headB；
2. 计算链表A,B的长度，并求出链表的长度差
3. 根据链表长度差更新cur指针所指向的节点，让curA,curB指针处于同一起点（链表尾节点对齐），因为链表相交部分的最长节点数<=最短链表长度
4. 根据curA,curB指针是否相等，寻找相交的节点

C++代码如下： 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;

        while(curA != NULL){//求链表A的长度
            curA = curA->next;
            lenA++;
        }
        while(curB != NULL) {//求链表B的长度
            curB = curB->next;
            lenB++;
        }
        curA = headA;//当前指针重新指向链表头节点
        curB = headB;
        if (lenA < lenB) {//让链表A为最长的链表，lenA为其长度
            swap(lenA,lenB);
            swap(curA,curB);
        }
        int gap = lenA - lenB;//计算两链表的长度差
        while(gap--){//让curA,curB在同一起点上，（链表末尾对齐）
            curA = curA->next;
        }
        while(curA != NULL) {
            /* 
            if (curA->val == curB->val){//此种写法，会遗漏curA,curB在同一起点所指向的节点为相交节点的情况
                 return curA->next;
             }
            */
            if (curA == curB){
                return curA;//返回两链表相交的起始节点
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;        
    }
};

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

142.环形链表II 

力扣题目链接

卡尔哥讲解

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改链表。

示例1：

输入：head = [3,2,0,-4], pos = 1

输出：返回索引为 1 的链表节点

解释：链表中有一个环，其尾部连接到第二个节点。

考察的知识点：

• 判断链表是否有环
• 若有环，如何确定环的入口 

  C++代码如下：

/**
 * 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) {//快指针每次向前移动2步，慢指针移动1步，确定链表是否有环
            slow = slow->next;
            fast = fast->next->next;
            //快慢指针相遇（链表有环），此时从head和相遇点，同时查找直至相遇（环的入口）
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                 while(index1 != index2){
                     index1 = index1->next;
                     index2 = index2->next;
                 }
                 return index2;//返回环的入口
            }
        }
        return NULL;        
    }
};