链表中删除结点的算法

237. 删除链表中的节点

有一个单链表的 head，我们想删除它其中的一个节点 node。

给你一个需要删除的节点 node 。你将 无法访问 第一个节点 head。

链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。

删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

• 给定节点的值不应该存在于链表中。
• 链表中的节点数应该减少 1。
• node 前面的所有值顺序相同。
• node 后面的所有值顺序相同。

自定义测试：

• 对于输入，你应该提供整个链表 head 和要给出的节点 node。node 不应该是链表的最后一个节点，而应该是链表中的一个实际节点。
• 我们将构建链表，并将节点传递给你的函数。
• 输出将是调用你函数后的整个链表。

示例 1：

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9

示例 2：

示例 2：

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9

提示：

• 链表中节点的数目范围是 [2, 1000]
• -1000 <= Node.val <= 1000
• 链表中每个节点的值都是 唯一 的
• 需要删除的节点 node 是 链表中的节点 ，且 不是末尾节点

题目解析

由于node不是链表中的最后一个节点，并且是给定节点的值不存在于链表中，我们就可以不删除对应node，而是删除其下一个节点，而把下一个节点的值放在node里面就可以了。如下图：

由此，代码也十分清晰了

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

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

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

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

题目分析

这道题一般的思路就是我们先遍历一遍数组，得到数组的长度，而后再遍历到倒数第n个node，今天可以用双指针来做这道题：

我们首先设置一个dummy结点（因为可能删除头结点），先将right指针放在dummy结点处，让right走n个结点后，再将left指针放在dummy结点上，同时前进，这样当right结点到最后一个结点的时候，left指针就到倒数第 n + 1 个结点处，也就是目标结点的前一个。这样就好写啦~

代码

/**
 * Definition for singly-linked list.
 * 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; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        ListNode right = dummy;
        ListNode left = dummy;
        while(n > 0){
            right = right.next;
            n --;
        }
        // 将left 移到倒数第 n + 1 个位置
        while(right != null && right.next != null){
            right = right.next;
            left = left.next;
        }
        left.next = left.next.next;
        return dummy.next;
    }
}

83. 删除排序链表中的重复元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

示例 1：

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

示例 2：

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

提示：

• 链表中节点数目在范围 [0, 300] 内
• -100 <= Node.val <= 100
• 题目数据保证链表已经按升序 排列

题目分析

这题比较简单，由于不需要删除头结点，所以不用设置dummy结点。逻辑比较简单就不过多赘述啦~

/**
 * Definition for singly-linked list.
 * 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; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null) return head;

        ListNode cur = head;
        while(cur.next != null){
            if(cur.next.val == cur.val)
                cur.next = cur.next.next;
            else
                cur = cur.next;
        }
        return head;
    }
}

82. 删除排序链表中的重复元素II

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

示例 1：

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

示例 2：

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

提示：

• 链表中节点数目在范围 [0, 300] 内
• -100 <= Node.val <= 100
• 题目数据保证链表已经按升序 排列

题目分析

首先检查边界，若链表为空（head == null），直接返回 head，因为空链表无需处理。

接着创建 dummy 节点（虚拟头节点），其值为 0，next 指向链表头节点 head。这么做是为了方便处理头节点可能被删的情况，让操作逻辑更统一。

定义指针 cur 指向 dummy 节点，用于遍历链表并处理重复节点。

进入循环 while(cur.next!= null && cur.next.next!= null)，确保至少有两个后续节点，以便判断是否有重复。

在循环内，先获取 cur 下一个节点的值 val。若 cur 下下一个节点的值也为 val，说明有重复，进入内层循环跳过所有值为 val 的节点。若不相等，就将 cur 移到下一个节点。

循环结束后，dummy.next 指向的就是删除重复节点后的链表，直接返回即可。整个过程简洁，无需额外复杂操作。

代码

/**
 * Definition for singly-linked list.
 * 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; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null) return head;
        ListNode dummy = new ListNode(0, head);
        ListNode cur = dummy;

        while(cur.next != null && cur.next.next != null){
            int val = cur.next.val;
            if(cur.next.next.val == val){
                while(cur.next != null && cur.next.val == val)
                    cur.next = cur.next.next;
            }
            else
                cur = cur.next;
        }
        return dummy.next;
    }
}