Remove Linked List Elements

                                            
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* current = dummy;
        
        while(current->next) {
            if(current->next->val == val) {
                ListNode* temp = current->next;
                current->next = current->next->next;
                delete temp;
            } else {
                current = current->next;
            }
        }
        
        return dummy->next;
    }
};

                                            
/**
 * 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) {
        while (head != null && head.val == val) {
            head = head.next;
        }
        ListNode current = head;
        while (current != null && current.next != null) {
            if (current.next.val == val) {
                current.next = current.next.next;
            } else {
                current = current.next;
            }
        }
        return head;
    }
}

                                            
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->next = head;
    struct ListNode* current = dummy;
    while(current->next){
        if(current->next->val == val){
            struct ListNode* temp = current->next;
            current->next = current->next->next;
            free(temp);
        } else {
            current = current->next;
        }
    }
    return dummy->next;
}

                                            
/**
 * 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) {
        while (head != null && head.val == val) {
            head = head.next;
        }
        ListNode current = head;
        while (current != null && current.next != null) {
            if (current.next.val == val) {
                current.next = current.next.next;
            } else {
                current = current.next;
            }
        }
        return head;
    }
}

                                            
/**
 * 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) {
    let dummy = new ListNode(0);
    dummy.next = head;
    let current = dummy;
    
    while(current.next !== null) {
        if(current.next.val === val) {
            current.next = current.next.next;
        } else {
            current = current.next;
        }
    }
    
    return dummy.next;
};

                                            
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */
function removeElements(head: ListNode | null, val: number): ListNode | null {
    while (head !== null && head.val === val) {
        head = head.next;
    }
    
    let current = head;
    while (current !== null && current.next !== null) {
        if (current.next.val === val) {
            current.next = current.next.next;
        } else {
            current = current.next;
        }
    }
    
    return head;
};

                                            
/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next;
 *     function __construct($val = 0, $next = null) {
 *         $this->val = $val;
 *         $this->next = $next;
 *     }
 * }
 */

class Solution {
    /**
     * @param ListNode $head
     * @param Integer $val
     * @return ListNode
     */
    function removeElements($head, $val) {
        $dummy = new ListNode(0);
        $dummy->next = $head;
        $current = $dummy;
        
        while($current->next != null) {
            if($current->next->val == $val) {
                $current->next = $current->next->next;
            } else {
                $current = $current->next;
            }
        }
        
        return $dummy->next;
    }
}

                                            
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init() { self.val = 0; self.next = nil; }
 *     public init(_ val: Int) { self.val = val; self.next = nil; }
 *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
 * }
 */

class Solution {
    func removeElements(_ head: ListNode?, _ val: Int) -> ListNode? {
        var dummy = ListNode(0)
        dummy.next = head
        var current: ListNode? = dummy
        
        while current?.next != nil {
            if current?.next?.val == val {
                current?.next = current?.next?.next
            } else {
                current = current?.next
            }
        }
        
        return dummy.next
    }
}

                                            
/**
 * Definition for singly-linked list.
 * class ListNode(var `val`: Int) {
 *     var next: ListNode? = null
 * }
 */
class Solution {
    fun removeElements(head: ListNode?, `val`: Int): ListNode? {
        var dummy = ListNode(-1)
        dummy.next = head
        var current = dummy
        while (current.next != null) {
            if (current.next!!.`val` == `val`) {
                current.next = current.next!!.next
            } else {
                current = current.next!!
            }
        }
        return dummy.next
    }
}

                                            
/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */

func removeElements(head *ListNode, val int) *ListNode {
    dummy := &ListNode{Val: 0, Next: head}
    prev := dummy
    current := head
    
    for current != nil {
        if current.Val == val {
            prev.Next = current.Next
        } else {
            prev = current
        }
        current = current.Next
    }
    
    return dummy.Next
}

                                            
# Definition for singly-linked list.
# class ListNode
#     attr_accessor :val, :next
#     def initialize(val = 0, _next = nil)
#     end
# end

def remove_elements(head, val)
    dummy = ListNode.new(0)
    dummy.next = head
    current = dummy

    while !current.next.nil?
        if current.next.val == val
            current.next = current.next.next
        else
            current = current.next
        end
    end

    return dummy.next
end

                                            
/**
 * Definition for singly-linked list.
 * class ListNode(_x: Int = 0, _next: ListNode = 
 * null) {
 * var next: ListNode = _next
 * var x: Int = _x
 * }
 */

object Solution {
  def removeElements(head: ListNode, `val`: Int): ListNode = {
    var dummy = new ListNode()
    dummy.next = head
    var current = dummy

    while (current.next != null) {
      if (current.next.x == `val`) {
        current.next = current.next.next
      } else {
        current = current.next
      }
    }

    return dummy.next
  }
}

To solve this coding challenge, we need to remove all elements from a linked list that match a given value and return the modified linked list.

Explanation

Understanding Linked List Structure : A linked list is a collection of nodes where each node contains a value and a reference ('next') to the next node in the sequence. The provided examples show us lists of nodes, and we need to manipulate these lists by removing nodes that have the specified value.
Handling Edge Cases :

Empty List : If the input list is empty (
head

is
null

), the output should also be an empty list.
Value Not Present : If the specified value does not exist in the list, the list should remain unchanged.
All Nodes Have the Value : If all nodes in the list have the specified value, the result should be an empty list.

Approach :

Dummy Node : Use a dummy node that points to the head of the list. This simplifies edge cases where the head node itself needs to be removed.
Traversal and Removal : Traverse the list starting from the dummy node. For each node, check if the next node's value is equal to the specified value:

If yes, skip the next node by pointing the current node's 'next' to the node after the next.
If no, move to the next node.

Return New Head : After the traversal, return the list starting from the dummy's next node, which is the new head of the list.

Detailed Steps in Pseudocode

Initialization :

Create a dummy node and set its 'next' to point to the head of the list.
Initialize a current node pointer to the dummy node.

Traversal :

While the current node's next node is not null:

Check if the next node's value matches the specified value.
If it does, skip the next node.
If it doesn't, move the current node pointer to the next node.

Return New Head :

Once the traversal is complete, return the node after the dummy node as the new head.

Pseudocode

                                            
# Function to remove elements from linked list
function removeElements(head, targetValue)
# Create a dummy node pointing to the head
dummyNode = new Node(0)
dummyNode.next = head

# Initialize current node to dummy
currentNode = dummyNode

# Traverse through the linked list
while currentNode.next is not null
# If value of next node is the target value
if currentNode.next.value == targetValue
# Remove the next node by skipping it
currentNode.next = currentNode.next.next
else
# Move current node to next node
currentNode = currentNode.next

# Return the new head of the list (node after dummy)
return dummyNode.next

Detailed Explanation:

Dummy Node Creation :

The dummy node helps manage cases where the head itself might be removed. By linking the dummy node to the head and always starting our removal checks from this dummy node, we can handle head removal easily without additional checks.

Current Node Initialization :

Start with the dummy node, ensuring we can manipulate the list even if the head node needs to be removed.

Traversal Loop :

The loop ensures we go through each node in the list, checking the value of each node and deciding whether to skip it or move to the next.
By adjusting the 'next' pointers, we effectively remove the nodes with the target value without breaking the rest of the list's structure.

Result Return :

Once all matching nodes are removed, the dummy's 'next' node gives the new head of the list. If the head was not removed, it remains the same; if it was removed, the new head starts from the first non-matching node.

By providing this detailed approach and pseudocode, the coding challenge can be effectively resolved.