力扣链接：203. 移除链表元素，难度等级：简单。
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例 1:
输入: head = [1,2,6,3,4,5,6], val = 6
输出: [1,2,3,4,5]
示例 2:
输入: head = [], val = 1
输出: []
示例 3:
输入: head = [7,7,7,7], val = 7
输出: []
约束:
- 列表中的节点数目在范围
[0, 10000]内 1 <= Node.val <= 500 <= val <= 50
思路
假设链表中待删除的节点是
d，d的前一个节点是p，所以p.next就是d。 删除d，只需要把p.next = p.next.next。因为用到了
p.next.next，所以循环条件应为while (p.next != null)，而不是while (p != null)。但
head节点前面没有节点，这就意味着需要对head节点进行特殊处理。是否有方法能够让
head节点的不再特殊呢？这样就不需要特殊处理head了。点击查看答案
办法是引入
dummy节点，dummy.next = head。
复杂度
时间复杂度
O(N)
空间复杂度
O(1)
Java #
/**
* 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 removeElements(ListNode head, int val) {
var dummyHead = new ListNode();
dummyHead.next = head;
var node = dummyHead;
while (node.next != null) {
if (node.next.val == val) {
node.next = node.next.next;
} else {
node = node.next;
}
}
return dummyHead.next;
}
}
Python #
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
dummy_head = ListNode()
dummy_head.next = head
node = dummy_head
while node.next:
if node.next.val == val:
node.next = node.next.next
else:
node = node.next
return dummy_head.next
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* removeElements(ListNode* head, int val) {
auto dummyHead = new ListNode();
dummyHead->next = head;
auto node = dummyHead;
while (node->next != nullptr) {
if (node->next->val == val) {
auto next_node = node->next;
node->next = node->next->next;
delete next_node;
} else {
node = node->next;
}
}
return dummyHead->next;
}
};
JavaScript #
/**
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
var removeElements = function (head, val) {
const dummyHead = new ListNode()
dummyHead.next = head
let node = dummyHead
while (node.next != null) {
if (node.next.val == val) {
node.next = node.next.next
} else {
node = node.next
}
}
return dummyHead.next
};
C# #
/**
* Definition for singly-linked list.
* public class ListNode {
* public int val;
* public ListNode next;
* public ListNode(int val=0, ListNode next=null) {
* this.val = val;
* this.next = next;
* }
* }
*/
public class Solution {
public ListNode RemoveElements(ListNode head, int val) {
var dummyHead = new ListNode();
dummyHead.next = head;
var node = dummyHead;
while (node.next != null) {
if (node.next.val == val) {
node.next = node.next.next;
} else {
node = node.next;
}
}
return dummyHead.next;
}
}
Go #
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func removeElements(head *ListNode, val int) *ListNode {
dummyHead := &ListNode{}
dummyHead.Next = head
node := dummyHead
for node.Next != nil {
if node.Next.Val == val {
node.Next = node.Next.Next
} else {
node = node.Next
}
}
return dummyHead.Next
}
Ruby #
# Definition for singly-linked list.
# class ListNode
# attr_accessor :val, :next
# def initialize(val = 0, _next = nil)
# @val = val
# @next = _next
# end
# end
def remove_elements(head, val)
dummy_head = ListNode.new
dummy_head.next = head
node = dummy_head
until node.next.nil?
if node.next.val == val
node.next = node.next.next
else
node = node.next
end
end
dummy_head.next
end