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

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

编程语言：C#

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

题意：

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

 思路：使用虚拟头结点简化操作。首先要考虑的是我们需要得到的结果长什么样：

图片出处：代码随想录代码随想录 (programmercarl.com)

然后在给定的初始链表中画出需要对指针指向做怎样的改动：

分析上图

1.首先cur会指向2，跳过了1，所以要先通过tmp1来保存1，再让cur指向2

2.2的下一个指向1(tmp1），改变了2原本的指向，所以要先通过tmp2来保存3，再让2指向1

3.最后让1的下一个指向3(tmp2)

就是说，每次改变指向时，思考会影响到哪个节点，就预先设置一个变量保存这个节点，再做指向修改操作

总结：本题是对两个节点进行交换，链表涉及到节点指向变更操作的，一般会影响到要操作的节点的上一个和下一个节点（和上期翻转链表同理），所以本题对两个节点操作，第一步要想到其实是需要对四个节点进行一定的操作

public class Solution {
    public ListNode SwapPairs(ListNode head) {
        ListNode dummyhead=new ListNode(0,head);
        ListNode cur=dummyhead;
        ListNode tmp1;
        ListNode tmp2;
        while(cur.next!=null&&cur.next.next!=null)//因为要处理两个节点
        {
            //需要先保存的两个节点一定要在开始操作前保存
            tmp1=cur.next;
            tmp2=cur.next.next.next;
            //步骤1
            cur.next=cur.next.next;
            //步骤2
            cur.next.next=tmp1;
            //步骤3
            cur.next.next.next=tmp2;
            //移动处理下一个
            cur=cur.next.next;
        }
        return dummyhead.next;
    }
}

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

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

题意：

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

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

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

示例 2：

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

示例 3：

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

思路：

双指针

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

1.定义fast指针和slow指针，初始值为虚拟头结点

2.fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）

3.fast和slow同时移动，直到fast指向末尾

4.删除slow指向的下一个节点

public class Solution {
    public ListNode RemoveNthFromEnd(ListNode head, int n) {
       ListNode dummyhead=new ListNode(0,head);
       ListNode slow=dummyhead;
       ListNode fast=dummyhead;
       //fast快指针先走n+1步
       while(n-->0&&fast!=null){
        fast=fast.next;
       }
       fast=fast.next;//多走一步是为了保证慢指针停在要删除的节点之前
       while(fast!=null){//同步移动
        fast=fast.next;
        slow=slow.next;
       }
       slow.next=slow.next.next;//删除节点
       return dummyhead.next;
    }
}

栈

思路：

1. 在这段代码中，首先创建了一个虚拟头节点(dummy)，用于简化对头节点的特殊处理。并将头节点连接到哑节点之后，整个操作在新建链表上进行。
2. 使用堆栈存储所有节点，这样可以便利的找到倒数第 n 个节点的前一个节点。
3. 遍历完整个链表，将每个节点都压入堆栈中。
4. 根据倒数第 n 个节点的位置，通过弹出 n 次来获取目标节点的前一个节点。
5. 获取到待删除节点的前一个节点后，直接删除目标节点，即将前一个节点的 next 指针指向下一个节点的下一个节点。
6. 最后返回处理后的链表头部，即哑节点(dummy)的 next 指针，即为删除倒数第 n 个节点后的链表。

 就是说多用一个栈存储遍历所有的ListNode对象，对栈进行操作找到倒数第n个节点的前一个节点，然后再对链表进行操作

public class Solution {
    public ListNode RemoveNthFromEnd(ListNode head, int n) {
      ListNode dummy = new ListNode(0); 
    dummy.next = head;  // 将头节点连接到哑节点之后
    Stack<ListNode> stk = new Stack<ListNode>();  // 使用堆栈存储节点
    ListNode cur = dummy;

    while (cur != null) {
        stk.Push(cur);
        cur = cur.next;
    }

    for (int i = 0; i < n; i++) {
        stk.Pop();
    }

    ListNode prev = stk.Peek();
    prev.next = prev.next.next;

    return dummy.next;  // 返回删除节点后的链表头部
    }
}

 02.07. 链表相交

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

题意：

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

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

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

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

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 0 <= m, n <= 3 * 104
• 1 <= Node.val <= 105
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

思路：

这种方法背后的关键思想是根据两个链表的长度差异，通过同时遍历两个链表来找到它们的相交点。类似快慢指针。

思考过程：

1. 观察题目特点： 针对单链表相交问题，首先想到的是如何在两个链表中找到相同的节点。
2. 利用快慢指针： 考虑使用两个指针分别指向两个链表头部，并同时移动这两个指针，直到它们相遇。
3. 处理链表长度不一致问题： 为了解决链表长度不一致的问题，我们可以让较短链表指针走完后指向较长链表的头部，这样可以保证两个指针同时移动的总步数是相等的。
4. 判断相交点： 如果两个链表有相交点，那么最终两个指针会在相交点处相遇；如果没有相交点，则会同时到达各自链表的末尾（null）。
5. 时间复杂度分析： 这种方法具有线性时间复杂度 O(m + n)，其中 m 和 n 分别是两个链表的长度。

public class Solution {
    public ListNode GetIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1=headA;
        ListNode p2=headB;
        while(p1!=p2){
            p1=p1==null?headB:p1.next;
            p2=p2==null?headA:p2.next;
        }
        return p1;
    }
}

 Leetcode 142.环形链表II

题目链接：142. 环形链表 II - 力扣（LeetCode）

题意：

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

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

说明：不允许修改给定的链表。

思路：

首先要解决判断链表有环的问题，利用快慢指针判断是否相遇

Leetcode 141环形链表

参考Leetcode 141环形链表141. 环形链表 - 力扣（LeetCode）

public class Solution {
     public bool HasCycle(ListNode head) {
        if (head == null || head.next == null) {
            return false;
        }

        ListNode fast = head;
        ListNode slow = head;

        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;

            if (fast == slow) {
                return true;  // 存在环
            }
        }

        return false;  // 不存在环
    }
}

 在这个基础上，寻找环的入口，最终要的是找到其中的数学规律

图片来源：代码随想录代码随想录 (programmercarl.com)

相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

去一个特殊情况：先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z

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

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

public 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){
                ListNode index1=fast;
                ListNode index2=head;
                while(index1!=index2){
                index1=index1.next;
                index2=index2.next;
                }
                return index2;
                }
        }
        return null;
    }
}

就是在找到相遇位置的时候通过x=z的特性找到入口，移动头结点指针和相遇位置指针直到相等退出循环，返回入口节点

ListNode index1=fast;
ListNode index2=head;
while(index1!=index2){
    index1=index1.next;
    index2=index2.next;

 }
    return index2;