文章目录
剑指offer 18 删除链表的节点
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
返回删除后的链表的头节点。
注意：此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明：
- 题目保证链表中节点的值互不相同
- 若使用
C或C++语言，你不需要free或delete被删除的节点
解题思路
由于头节点也是有可能被删除的，所以应该建立一个虚拟头节点dummy用于辅助删除头节点的操作，同时用双指针方法的话，设立dummy可以将操作统一。
Java代码
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode deleteNode(ListNode head, int val) {
if(head == null) return null;
ListNode dummy = new ListNode(0);//建立虚拟的头节点
dummy.next = head;
ListNode pre = dummy;//pre指向要删除节点的前一节点，用于改变pre.next的指向，从而删除节点
ListNode cur = head;//cur指向当前要进行判断是否要删除的节点
while(cur != null){
if(cur.val == val){
//当前节点是要删除的节点，则让pre.next指向cur.next即可
pre.next = cur.next;
break;//已经删除了节点，可以退出循环了
}
pre = pre.next;//当前节点不是要删除的节点，让pre和cur都往后移一个节点
cur = cur.next;
}
return dummy.next;
}
}
扩展题1：LeetCode 237 删除链表中的节点的变形题
237. 删除链表中的节点
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。
现有一个链表 – head = [4,5,1,9]，它可以表示为:
示例 1：
输入： head = [4,5,1,9], node = 5
输出：[4,1,9]
解释： 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2：
输入： head = [4,5,1,9], node = 1
输出：[4,5,9]
解释： 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
提示：
- 链表至少包含两个节点。
- 链表中所有节点的值都是唯一的。
- 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
- 不要从你的函数中返回任何结果。
解题思路
本题其实就是另一种删除链表节点的思路，即我们知道，链表中要删除某个节点的时候，不能通过自己删除自己，而是需要他的前一个节点的next指针改变指向从而删除节点。但是换个思考方式，我们将要删除的节点改成和他的下一个节点一样，而后删除他的下一个节点，这和删除他本身效果是一样的。
- 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O ( 1 ) O(1) O(1)。
- 如果该节点是尾节点，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向
null，时间复杂度为 O ( N ) O(N) O(N)。
综上，如果进行 N N N 次操作，那么大约需要操作节点的次数为 N − 1 + N = 2 N − 1 N-1+N=2N-1 N−1+N=2N−1，其中 N − 1 N-1 N−1 表示 N − 1 N-1 N−1 个不是尾节点的每个节点以 O ( 1 ) O(1) O(1) 的时间复杂度操作节点的总次数， N N N 表示 1 1 1 个尾节点以 O ( N ) O(N) O(N) 的时间复杂度操作节点的总次数。 2 N − 1 N ≈ 2 \frac{2N - 1}{N }\approx2 N2N−1≈2，因此该算法的平均时间复杂度为 O ( 1 ) O(1) O(1)。
Java代码
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public void deleteNode(ListNode node) {
/*直接将要删除结点的下一结点的值复制给要删除结点，然后删除下一结点
这就相当于删除了要删除的结点，时间是O(1)，但如果要删除尾结点，则需要从头遍历，
或者要删除的是头节点，则head = head.next，但本题要求较少，
不用考虑要删除的节点是尾节点的情况*/
node.val = node.next.val;
node.next = node.next.next;
}
}
这里也附上要考虑删除的是头节点或者是尾结点的代码
public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
if (head == null || tobeDelete == null)
return head;
if (tobeDelete.next != null) {
// 要删除的节点不是尾节点
tobeDelete.val = tobeDelete.next.val;
tobeDelete.next = tobeDelete.next.next;
} else {
if (head == tobeDelete)
// 要删除的是头节点
head = head.next;
else {
//要删除的是尾结点
ListNode cur = head;
while (cur.next != tobeDelete)
cur = cur.next;
cur.next = null;
}
}
return head;
}
扩展题2：LeetCode 83 删除排序链表中的重复元素I
83. 删除排序链表中的重复元素
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3
解题思路
链表中的元素已经是排序的，故从头至尾遍历即可。后一个元素和前一个元素相同则删除，删除方式和上面几题一样，这里的head肯定是不需要删除的，故不需要建立虚拟头节点dummy。
Java代码
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if(head == null || head.next == null) return head;
ListNode cur = head;//辅助遍历链表
while(cur!=null && cur.next !=null){
//后一个结点的值与前一结点的值相等，删除该结点
if(cur.val == cur.next.val) cur.next = cur.next.next;
else cur = cur.next;//后一个结点的值与前一结点的值不相等，更新cur，即cur后移
}
return head;
}
}
扩展题3：LeetCode 82 删除排序链表中的重复元素II
82. 删除排序链表中的重复元素 II
给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。
示例 1:
输入: 1->2->3->3->4->4->5
输出: 1->2->5
示例 2:
输入: 1->1->1->2->3
输出: 2->3
解题思路
由于头结点也可能是重复的会被删除，所以建立虚拟结点dummy，使得操作统一。我们要把当前为某个值的前一结点pre记录下来，和后面值比当前结点的值大的结点相连。
Java代码
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if(head == null || head.next == null) return head;
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode pre = dummy;
//由于要用到pre.next.val所以要判断pre.next!=null
while(pre != null && pre.next != null){
ListNode cur = pre.next;
//让cur指向第一个值不为pre.next.val的结点
while(cur != null && pre.next.val == cur.val) cur = cur.next;
//如果cur只跨越了一个结点，说明cur跨越的该段不重复，那么就不用删除，移动pre即可
if(pre.next.next == cur) pre = pre.next;
else{
//cur跨越了多个结点，目前指向了第一个值不为pre.next.val的结点
//故直接让pre.next = cur,相当于删除了cur跨越的重复的那段
pre.next = cur;
}
}
return dummy.next;//返回dummy.next
}
}
