1import java.util.HashSet;
2import java.util.Set;
3
4// Definition for singly-linked list.
5public class ListNode {
6    int val;
7    ListNode next;
8
9    // Default constructor
10    ListNode() {}
11  
12    // Constructor with value initialization
13    ListNode(int val) { 
14        this.val = val; 
15    }
16  
17    // Constructor with value and next node initialization
18    ListNode(int val, ListNode next) { 
19        this.val = val; 
20        this.next = next; 
21    }
22}
23
24class Solution {
25    // Method to modify the linked list by removing nodes that have values present in the nums array
26    public ListNode modifiedList(int[] nums, ListNode head) {
27        Set<Integer> valueSet = new HashSet<>();
28      
29        // Add all elements of the array nums to a HashSet for quick lookup
30        for (int number : nums) {
31            valueSet.add(number);
32        }
33      
34        // Create a dummy node to simplify edge cases where removal is needed at the head
35        ListNode dummy = new ListNode(0, head);
36      
37        // Iterate through the linked list using 'pre' as a pointer to the node before the current
38        for (ListNode pre = dummy; pre.next != null;) {
39            // If the current node's value is in the set, remove it by skipping over it
40            if (valueSet.contains(pre.next.val)) {
41                pre.next = pre.next.next;
42            } else {
43                // Otherwise, move the 'pre' pointer to the next node
44                pre = pre.next;
45            }
46        }
47      
48        // Return the new head of the list, which is next to the dummy node
49        return dummy.next;
50    }
51}
52

1#include <vector>
2#include <unordered_set>
3
4/**
5 * Definition for singly-linked list.
6 */
7struct ListNode {
8    int val;            // Value of the list node
9    ListNode *next;     // Pointer to the next list node
10  
11    // Default constructor initializing with zero and nullptr
12    ListNode() : val(0), next(nullptr) {}
13  
14    // Constructor to initialize node with a given value and nullptr
15    ListNode(int x) : val(x), next(nullptr) {}
16  
17    // Constructor to initialize node with a given value and pointer to the next node
18    ListNode(int x, ListNode *next) : val(x), next(next) {}
19};
20
21class Solution {
22public:
23    /**
24     * This function modifies the input linked list by removing nodes that contain
25     * values present in the given vector `nums`.
26     *
27     * @param nums Vector of integers whose values need to be removed from the list.
28     * @param head Pointer to the head of the singly-linked list.
29     * @return Pointer to the head of the modified linked list.
30     */
31    ListNode* modifiedList(std::vector<int>& nums, ListNode* head) {
32        // Create a set with elements from nums for efficient lookup
33        std::unordered_set<int> values_set(nums.begin(), nums.end());
34
35        // Dummy node to handle edge cases easily (like deletion of the head node)
36        ListNode* dummy = new ListNode(0, head);
37
38        // Pointer to traverse the list, initially pointing to dummy node
39        ListNode* prev = dummy;
40
41        // Traverse the linked list
42        while (prev->next) {
43            // If the next node's value is in the set, skip the node by changing pointers
44            if (values_set.count(prev->next->val)) {
45                prev->next = prev->next->next;
46            } else {
47                // Otherwise, move prev pointer forward
48                prev = prev->next;
49            }
50        }
51
52        // Return the head of the modified list, which is next of dummy node
53        return dummy->next;
54    }
55};
56

1/**
2 * Definition for singly-linked list node.
3 */
4class ListNode {
5    val: number;
6    next: ListNode | null;
7
8    constructor(val?: number, next?: ListNode | null) {
9        this.val = (val === undefined ? 0 : val);
10        this.next = (next === undefined ? null : next);
11    }
12}
13
14/**
15 * Modifies the linked list based on the values present in the nums array.
16 * Removes nodes from the linked list that contain values present in the nums array.
17 * 
18 * @param nums - Array of numbers to be removed from the linked list.
19 * @param head - Head of the original linked list.
20 * @returns - New head of the modified linked list.
21 */
22function modifiedList(nums: number[], head: ListNode | null): ListNode | null {
23    // Create a set from nums to quickly check for existence.
24    const valuesToRemove: Set<number> = new Set(nums);
25
26    // Initialize a dummy node that points to the head.
27    const dummy: ListNode = new ListNode(0, head);
28
29    // Iterate through the linked list.
30    for (let currentPointer = dummy; currentPointer.next; ) {
31        // If the value of the next node exists in the set, remove the node.
32        if (valuesToRemove.has(currentPointer.next.val)) {
33            currentPointer.next = currentPointer.next.next;
34        } else {
35            // Otherwise, move the pointer forward.
36            currentPointer = currentPointer.next;
37        }
38    }
39  
40    // Return the new head of the list, which is the next of the dummy node.
41    return dummy.next;
42}
43