代码随想录算法训练营第五天（1）|24. 两两交换链表中的节点，19.删除链表的倒数第N个节点

文档讲解：代码随想录

难度：一般嗷~~

引用：代码随想录 链表

Java中并没有定义ListNode这个节点类，包括单向链表，双向链表，循环链表，都需要去学习它的写法，自定义

在处理链表的题目时，要注意通过画图的方法来摸清楚各个节点的应用和处理模式

在Java中自定义一个节点类（ListNode）

public class ListNode {
    int val;
    ListNode next;
 
    ListNode() {}
 
    ListNode(int val) { 
        this.val = val; 
    }
 
    ListNode(int val, ListNode next) { 
        this.val = val;
        this.next = next; 
    }
}

 引用自：代码随想录 链表

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

力扣题目链接(opens new window)

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

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

视频：《代码随想录》算法视频公开课 (opens new window)：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点

思路：

通过设置一个虚拟的头节点，可以让所有需要进行操作的链表数据使用同一块代码，可以让代码更简洁。（减去了判断头节点和对头节点的操作）

操作步骤如下：

1. 对需要交换的两个节点记录即firstnode，secondnode。
2. 对secondnode的下一个节点记录（避免交换后脱离出链表）。
3. 进行判断：剩下的节点是否够两个，以进行交换。
4. 对firstnode，secondnode及secondnode的下一个节点赋值。
5. 交换。
6. 将链表更新，并进入下一次循环。

补充： new ListNode(-1)：这是创建一个新 ListNode 实例的表达式，其中 -1 是这个新节点的数据值。这里 -1 是一个任意的选择，通常用于初始化，表示这个节点不存储有效的数据，仅仅作为一个占位符使用

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
        // new ListNode(-1)：这是创建一个新 ListNode 实例的表达式，
        // 其中 -1 是这个新节点的数据值。这里 -1 是一个任意的选择，
        // 通常用于初始化，表示这个节点不存储有效的数据，仅仅作为一个占位符使用
        dumyhead.next = head; // 将虚拟头结点指向head，这样方便后面做删除操作
        ListNode cur = dumyhead;
        ListNode temp; // 临时节点，保存两个节点后面的节点
        ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点
        ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点
        while (cur.next != null && cur.next.next != null) {
            temp = cur.next.next.next;
            firstnode = cur.next;
            secondnode = cur.next.next;
            
            cur.next = secondnode;       
            secondnode.next = firstnode; 
            firstnode.next = temp;  

            cur = firstnode; // cur移动，准备下一轮交换
        }
        return dumyhead.next;  
    }
}

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

力扣题目链接(opens new window)

给你一个链表，删除链表的倒数第 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]

视频：《代码随想录》算法视频公开课 (opens new window)：：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点

 思路：

1. 定义fast指针和slow指针，初始值为虚拟头结点
2. fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）
3. fast和slow同时移动，直到fast指向末尾
4. 删除slow指向的下一个节点

注意：该题为返回链表的头结点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
         //新建一个虚拟头节点指向head
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;
        //快慢指针指向虚拟头节点
        ListNode fastIndex = dummyNode;
        ListNode slowIndex = dummyNode;

        // 只要快慢指针相差 n 个结点即可
        for (int i = 0; i <= n; i++) {
            fastIndex = fastIndex.next;
        }
        while (fastIndex != null) {
            fastIndex = fastIndex.next;
            slowIndex = slowIndex.next;
        }

        // 此时 slowIndex 的位置就是待删除元素的前一个位置。
        // 检查 slowIndex.next 是否为 null，以避免空指针异常
        if (slowIndex.next != null) {
            slowIndex.next = slowIndex.next.next;
        }
        return dummyNode.next;
    }
}

 返回dummyNode.next原因

1. 处理头节点被删除的情况：

   • 如果链表的长度与 n 相等，那么我们要删除的是链表的第一个节点（即原来的头节点）。在这种情况下，slowIndex 将指向虚拟头节点 dummyNode，而 slowIndex.next 将指向原链表的头节点。
   • 删除操作后，slowIndex.next 将变为指向第二个节点（新的头节点），因此返回 dummyNode.next 可以正确返回新的头节点。

2. 避免直接修改原头节点：

   • 如果直接返回 head，而删除操作会导致 head 变成 null（例如当原链表只有一个节点时），那么返回的将是一个空值，不符合预期。
   • 使用 dummyNode 提供了一个稳定的引用，确保无论是否删除头节点，都能正确返回链表的头部。