Remove Duplicates From Sorted List Ii

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

                                            
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* deleteDuplicates(struct ListNode* head){
    if (!head || !head->next) return head;
    
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = -101;
    dummy->next = head;
    struct ListNode* prev = dummy;
    struct ListNode* curr = head;
    
    while (curr) {
        if (curr->next && curr->val == curr->next->val) {
            while (curr->next && curr->val == curr->next->val) curr = curr->next;
            prev->next = curr->next;
        } else {
            prev = prev->next;
        }
        curr = curr->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 DeleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;
        
        while (head != null) {
            if (head.next != null && head.val == head.next.val) {
                while (head.next != null && head.val == head.next.val) {
                    head = head.next;
                }
                prev.next = head.next;
            } else {
                prev = prev.next;
            }
            head = head.next;
        }
        
        return dummy.next;
    }
}

                                            
/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */

var deleteDuplicates = function(head) {
    if (head === null || head.next === null) return head;

    let dummy = new ListNode(0);
    dummy.next = head;
    let prev = dummy;

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

                                            
/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public ListNode $next = null;
 *     function __construct($val = 0, $next = null) {
 *         $this->val = $val;
 *         $this->next = $next;
 *     }
 * }
 */
class Solution {
    /**
     * @param ListNode $head
     * @return ListNode
     */
    function deleteDuplicates($head) {
        $dummy = new ListNode(0);
        $dummy->next = $head;
        $prev = $dummy;
        while ($head != null) {
            if ($head->next != null && $head->val == $head->next->val) {
                while ($head->next != null && $head->val == $head->next->val) {
                    $head = $head->next;
                }
                $prev->next = $head->next;
            } else {
                $prev = $prev->next;
            }
            $head = $head->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 deleteDuplicates(_ head: ListNode?) -> ListNode? {
        var dummy = ListNode(0)
        dummy.next = head
        var current: ListNode? = dummy
        
        while current?.next != nil && current?.next?.next != nil {
            if current!.next!.val == current!.next!.next!.val {
                let duplicateValue = current!.next!.val
                while current?.next != nil && current!.next!.val == duplicateValue {
                    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 deleteDuplicates(head *ListNode) *ListNode {
    dummy := &ListNode{Val: 0, Next: head}
    prev := dummy
    for head != nil {
        if head.Next != nil && head.Val == head.Next.Val {
            for head.Next != nil && head.Val == head.Next.Val {
                head = head.Next
            }
            prev.Next = head.Next
        } else {
            prev = prev.Next
        }
        head = head.Next
    }
    return dummy.Next
}

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

def delete_duplicates(head)
    dummy = ListNode.new(0)
    dummy.next = head
    current = dummy

    while current.next && current.next.next
        if current.next.val == current.next.next.val
            value = current.next.val
            while current.next && current.next.val == value
                current.next = current.next.next
            end
        else
            current = current.next
        end
    end

    return dummy.next
end

                                            
/**
 * Definition for singly-linked list.
 * class ListNode(_x: Int = 0, _next: ListNode = null) {
 *     var x: Int = _x
 *     var next: ListNode = _next
 * }
 */
object Solution {
    def deleteDuplicates(head: ListNode): ListNode = {
        if (head == null || head.next == null) return head
        if (head.x != head.next.x) {
            head.next = deleteDuplicates(head.next)
            return head
        } else {
            var curr: ListNode = head
            while (curr != null && curr.x == head.x) {
                curr = curr.next
            }
            return deleteDuplicates(curr)
        }
    }
}

To solve this coding challenge, we need to remove all nodes from a sorted linked list that have duplicate numbers, leaving only distinct numbers, and return the sorted linked list. Below, I explain the methodology and provide a detailed step-by-step pseudocode to achieve the solution.

Explanation

We start by examining the properties of the linked list given:

The linked list is sorted in ascending order.
We will delete nodes that have duplicates, ensuring that only unique values remain.

Our approach involves the following:

Dummy Node : We use a dummy node to handle edge cases, such as removing the first node of the list. The dummy node points to the head of the list.
Two Pointers : We use two pointers,
prev

(to track the end of the current unique segment) and
head

(to traverse through the list).
Identify Duplicates : As we traverse the list, we check if the current node's value is equal to the next node's value. If it is, there are duplicates. We then skip over all nodes with this duplicate value.
Update Links : Once duplicates are bypassed, we link the
prev

pointer to the next unique value node.
Return Result : At the end of the traversal, the list starting from
dummy.next

will have all duplicates removed and only unique nodes.

Step-by-Step Explanation / Detailed Steps in Pseudocode

Initialize Dummy Node : Create a dummy node that points to the head of the list.
Set up Pointers : Initialize
prev

to the dummy node and
head

to the head of the list.
Traverse the List :

While
head

is not null:

Check if
head.next

is not null and
head.val

is equal to
head.next.val

.

If true, it means duplicates exist:

Skip all nodes with this duplicate value by advancing
head

pointer until the value changes.
Link
prev.next

to the next unique node by setting
prev.next

to
head.next

.

If false, advance the
prev

pointer to the current
head

.

Move
head

to the next node.

Return the Result : Return
dummy.next

, which is the head of the modified list with duplicates removed.

Here's the pseudocode for this solution:

                                            
# Class definition for ListNode, used for creating new list nodes
Class ListNode:
    Function __init__(val, next=null):
        self.val = val
        self.next = next

Function deleteDuplicates(head):
    # If the list is empty or has single node, return head directly as no duplicates exist
    If head is null OR head.next is null:
        Return head

    # Create a dummy node pointing to the head of the list
    dummy = new ListNode(0)
    dummy.next = head

    # Initialize the ‘prev’ pointer to dummy and ‘head’ pointer to the head of the list
    prev = dummy

    # Traverse the entire list
    While head is not null:
        # If the current node and the next node have the same value, it indicates duplicates
        If head.next is not null AND head.val == head.next.val:
            # Skip all nodes with this duplicate value
            While head.next is not null AND head.val == head.next.val:
                head = head.next
            # Connect 'prev.next' to the node after the duplicates
            prev.next = head.next
        Else:
            # If no duplicates, advance 'prev' to next node
            prev = prev.next
        # Move ‘head’ to the next node in the list
        head = head.next

    # Return the new head of the list which is dummy.next
    Return dummy.next

This pseudocode clearly outlines each step and incorporates comments for better understanding of each action being performed. It adheres to the method of solving the coding challenge, ensuring no unnecessary language-specific constructs are used.