力扣203(java&python)-移除链表元素（简单）

题目：

给你一个链表的头节点 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, 104] 内
• 1 <= Node.val <= 50
• 0 <= val <= 50

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/remove-linked-list-elements
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：

添加一个虚拟头结点，并把虚拟头结点的下一个结点指向原始的头结点，在当前结点后还有结点的情况下，遍历并删除val的结点，最后返回虚拟头结点的下一个结点即可。

具体的遍历删除方法为：

• 定义一个虚拟结点,并指向原链表的头结点；
• 定义当前结点cur并初始化为虚拟头结点；
• 当前结点后还有结点时，进行遍历，当当前结点的下一个结点是待删除的结点时，就将当前节点指向它下一结点的下一结点（删除当前结点的下一结点），否则右移当前结点到当前结点的下一结点；
• 最后返回虚拟结点的下一个结点即可。

注意：

1.cur.next.val == val，而不是cur.next = val?

val表示的是一个值，cur.next表示的是cur的下一个结点的地址，而cur.next.val 表示的是下一个结点的值，题目要求的是删除链表中给定值的结点，应该是值与值进行比较，而不应该是结点地址与值进行比较。

2.最后返回的是 dummyHead.next，而不是cur.next?

最开始将虚拟结点dummyHead赋值给cur，但是后续遍历过程中cur一直在移动，导致最后遍历完链表时，cur指向的是链表末尾的那个结点，而dummyHead没有移动。

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) {
        //定义一个虚拟结点,并指向原链表的头结点
        ListNode dummyHead = new ListNode(0, head);
        //定义当前结点cur并初始化为虚拟头结点
        ListNode cur = dummyHead;
        //当前结点后还有结点
        while(cur.next != null){
            //当前结点的下一个结点是待删除的结点
            if(cur.next.val == val){
                //将当前节点指向它下一结点的下一结点（删除当前结点的下一结点）
                cur.next = cur.next.next;
            }else{
                //右移当前结点到当前结点的下一结点
                cur = cur.next;
            }
        }
        //返回头结点是虚拟节点的下一个
        return dummyHead.next;
    }
}

 Python3:

# 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]:
        dummyHead = ListNode(0, head)
        cur = dummyHead
        while cur.next:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummyHead.next

 小知识：

初始化链表：

①初始化一个空节点，初始赋值为0，指针指向为list;

ListNode list = new ListNode(0);

②初始化一个空节点，初始赋值为0，并且list的下一个next指针指向head，指针指向为list;（通常定义一个空节点还需要有节点的next指针指向，否则只是定义一个空节点）

ListNode list = new ListNode(0,head);
或者
ListNode list = new ListNode(0); 
list.next=head;

③定义一个空链表

ListNode list=null;