How do you approach Remove Linked List Elements?

Walk the list and keep only the nodes whose value differs from val.

What is the time complexity of Remove Linked List Elements?

Time complexity: O(n) - one pass. Space complexity: O(1) extra on a real list (O(n) for the result array here).

What are common mistakes on Remove Linked List Elements?

Reassigning next before saving it, which loses the rest of the list. Skipping the dummy head, which forces a special case every time the real head changes. Advancing the fast pointer without checking both fast and fast.next - the null dereference only shows up on even-length lists.

gitGood.dev

← Back to problems

Remove Linked List Elements

EasyData Structures

Description

Given the head of a linked list and an integer `val`, remove all the nodes of the linked list that have `Node.val == val`, and return the new head. **Note:** For this problem, linked lists are represented as arrays for simplicity. The function takes the list as an array and should return the resulting list as an array.

Example 1

Input: head = [1,2,6,3,4,5,6], val = 6

Output: [1,2,3,4,5]

Example 2

Input: head = [], val = 1

Output: []

Example 3

Input: head = [7,7,7,7], val = 7

Output: []

Constraints

- The number of nodes in the list is in the range [0, 10^4]. - 1 <= Node.val <= 50 - 0 <= val <= 50

Remove Linked List Elements: approach, complexity and pitfalls

An easy linked list problem, graded against 6 test cases (3 of them hidden).

The pattern: Linked List

Pointer manipulation - reversal, cycle detection, and merging without extra space.

Reach for it when you see: Any problem handing you a list head, especially with an O(1) space constraint.

If you are stuck

Show the 3-step hint ladder

Walk the list and keep only the nodes whose value differs from val.
Watch the edge cases: the value to remove can appear at the head, at the tail, or in a consecutive run.
On a real linked list you would use a dummy head node so that deleting the first node is no special case - here, building a filtered result achieves the same thing.

The optimal approach

Show the approach: Single Pass Filter

Traverse the list once and keep every node whose value is not `val`. On a pointer-based linked list the classic trick is a dummy head node pointing at the real head, so removing leading matches needs no special case - you always look at `current.next` and splice it out when it matches.

Time: O(n) - one pass
Space: O(1) extra on a real list (O(n) for the result array here)

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Empty input. At least one case passes an empty collection. Make sure your loop bounds and any "first element" read survive a length of zero.
Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.

Common Linked List mistakes

These apply to the pattern as a whole, not just this problem.

Reassigning `next` before saving it, which loses the rest of the list.
Skipping the dummy head, which forces a special case every time the real head changes.
Advancing the fast pointer without checking both `fast` and `fast.next` - the null dereference only shows up on even-length lists.

← Back to problems

Remove Linked List Elements

EasyData Structures

Description

Example 1

Input: head = [1,2,6,3,4,5,6], val = 6

Output: [1,2,3,4,5]

Example 2

Input: head = [], val = 1

Output: []

Example 3

Input: head = [7,7,7,7], val = 7

Output: []

Constraints

- The number of nodes in the list is in the range [0, 10^4]. - 1 <= Node.val <= 50 - 0 <= val <= 50

Remove Linked List Elements: approach, complexity and pitfalls

An easy linked list problem, graded against 6 test cases (3 of them hidden).

The pattern: Linked List

Pointer manipulation - reversal, cycle detection, and merging without extra space.

Reach for it when you see: Any problem handing you a list head, especially with an O(1) space constraint.

If you are stuck

Show the 3-step hint ladder

Walk the list and keep only the nodes whose value differs from val.
Watch the edge cases: the value to remove can appear at the head, at the tail, or in a consecutive run.
On a real linked list you would use a dummy head node so that deleting the first node is no special case - here, building a filtered result achieves the same thing.

The optimal approach

Show the approach: Single Pass Filter

Time: O(n) - one pass
Space: O(1) extra on a real list (O(n) for the result array here)

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Empty input. At least one case passes an empty collection. Make sure your loop bounds and any "first element" read survive a length of zero.
Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.

Common Linked List mistakes

These apply to the pattern as a whole, not just this problem.

Reassigning `next` before saving it, which loses the rest of the list.
Skipping the dummy head, which forces a special case every time the real head changes.
Advancing the fast pointer without checking both `fast` and `fast.next` - the null dereference only shows up on even-length lists.