Remove Duplicates From Sorted List

                                            
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        
        ListNode* current = head;
        
        while (current->next != nullptr) {
            if (current->val == current->next->val) {
                ListNode* temp = current->next;
                current->next = current->next->next;
                delete temp;
            } else {
                current = current->next;
            }
        }
        
        return head;
    }
};

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

                                            
class Solution:
    def deleteDuplicates(self, head):
        current = head
        while current and current.next:
            if current.val == current.next.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* deleteDuplicates(struct ListNode* head) {
    struct ListNode* current = head;
    while(current != NULL && current->next != NULL){
        if(current->val == current->next->val){
            struct ListNode* temp = current->next;
            current->next = current->next->next;
            free(temp);
        } else {
            current = current->next;
        }
    }
    return head;
}

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

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

                                            
class Solution {
    /**
     * Definition for a singly-linked list.
     * class ListNode {
     *     public $val = 0;
     *     public $next = null;
     *     function __construct($val = 0, $next = null) {
     *         $this->val = $val;
     *         $this->next = $next;
     *     }
     * }
     */
    
    /**
     * @param ListNode $head
     * @return ListNode
     */
    function deleteDuplicates($head) {
        $current = $head;
        
        while ($current != null && $current->next != null) {
            if ($current->val == $current->next->val) {
                $current->next = $current->next->next;
            } else {
                $current = $current->next;
            }
        }
        
        return $head;
    }
}

                                            
/**
 * 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 current = head

        while current != nil && current?.next != nil {
            if current?.val == current?.next?.val {
                current?.next = current?.next?.next
            } else {
                current = current?.next
            }
        }

        return head
    }
}

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

func deleteDuplicates(head *ListNode) *ListNode {
    current := head
    for current != nil && current.Next != nil {
        if current.Val == current.Next.Val {
            current.Next = current.Next.Next
        } else {
            current = current.Next
        }
    }
    return head
}

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

                                            
use std::collections::HashSet;

// Definition for singly-linked list.
// #[derive(PartialEq, Eq, Clone, Debug)]
// pub struct ListNode {
//   pub val: i32,
//   pub next: Option<Box<ListNode>>
// }

impl Solution {
    pub fn delete_duplicates(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        let mut current = head;
        let mut unique_values = HashSet::new();
        let mut new_head = None;
        
        while let Some(mut node) = current {
            let val = node.val;
            
            if !unique_values.contains(&val) {
                unique_values.insert(val);
                if new_head.is_none() {
                    new_head = Some(Box::new(ListNode { val, next: None }));
                } else {
                    let mut tail = new_head.as_mut().unwrap();
                    while tail.next.is_some() {
                        tail = tail.next.as_mut().unwrap();
                    }
                    tail.next = Some(Box::new(ListNode { val, next: None }));
                }
            }
            
            current = node.next.take();
        }
        
        new_head
    }
}

                                            
# Definition for singly-linked list.
#
# defmodule ListNode do
#   @type t :: %__MODULE{
#     val: integer,
#     next: %__MODULE.t | nil
#   }
# end

defmodule Solution do
  def delete_duplicates(head) do
    case head do
      nil -> nil
      %ListNode{val: val, next: nil} -> %ListNode{val: val, next: nil}
      %ListNode{val: val, next: %ListNode{val: val, next: next}} ->
        delete_duplicates(%ListNode{val: val, next: next})
      %ListNode{val: val, next: next} ->
        %ListNode{val: val, next: delete_duplicates(next)}
    end
  end
end

To solve this coding challenge, we need to focus on modifying a sorted linked list to remove any duplicate elements. Let's break down the problem and build the solution step-by-step, ensuring all duplicates are removed and only unique elements remain. Here's a detailed explanation followed by pseudocode.

Explanation

Problem Breakdown

We start with a sorted linked list, which means all the elements in the linked list are in ascending order.
The goal is to traverse the linked list and remove any duplicate nodes such that each element appears only once in the resulting linked list.
We return the modified linked list that retains the sorted order but has no duplicate elements.

Approach

Initialization :

Use a pointer
current

to traverse the linked list.
Start
current

at the head of the linked list.

Traverse the Linked List :

While traversing, compare the value of the current node with the value of the next node.
If both values are the same, this indicates a duplicate. We need to change the
next

pointer of the current node to skip the next node, effectively removing the duplicate.
If the values are different, move the
current

pointer to the next node.

End Traversal :

Continue this process until we reach the end of the linked list (
current

or
current.next

becomes
null

).
The list is already sorted, so no need to perform additional sorting.

Detailed Steps in Pseudocode

Initialize Pointer :

Set
current

to point to the head of the linked list.

While Loop :

Continue looping while
current

is not
null

and
current.next

is not
null

.
Inside the loop, check if
current.val

equals
current.next.val

.

Remove Duplicate Node :

If the values are equal, adjust the pointers to skip over the duplicate node.
If the values are different, move the
current

pointer to the next node.

Return Result :

Once the loop terminates, the linked list will have all duplicates removed.

Pseudocode

                                            
// Definition of ListNode
class ListNode:
// Constructor to create a new node
def __init__(self, value):
self.val = value  // Value of the node
self.next = None  // Pointer to the next node

// Function to delete duplicates
function deleteDuplicates(head):
if head is None:
// If the list is empty, simply return the head
return head

// Initialize the current pointer to the head of the list
current = head

// Traverse the list until current and current.next are not null
while current is not null and current.next is not null:
// Check if current node value is equal to the next node value
if current.val == current.next.val:
// If they are equal, we have found a duplicate
// Skip the next node by linking current node to the node after the next node
current.next = current.next.next
else:
// If they are not equal, move the current pointer to the next node
current = current.next

// After removing duplicates, return the head of the list
return head

Step-by-Step Explanation of Pseudocode

Definition of ListNode :

We define a
ListNode

class which contains an integer value
val

and a pointer
next

to the next node in the list.

Function to delete duplicates :

The function
deleteDuplicates

accepts the
head

of the linked list as an argument.
It first checks if the head is
null

(i.e., the list is empty). If it is, it returns
head

immediately since there are no elements to process.

Initialize
current

pointer :

Set the
current

pointer to the head of the linked list.

While Loop :

We enter a while loop that runs as long as
current

and
current.next

are not
null

.
Inside the loop, we compare
current.val

with
current.next.val

.

Remove Duplicate Node :

If
current.val

equals
current.next.val

, it indicates a duplicate. We set
current.next

to
current.next.next

to remove the duplicate.
If the values are not equal, we simply move
current

to
current.next

.

Return Result :

Finally, after the while loop completes, we return the
head

of the modified linked list. The list will be free of duplicates and still in sorted order.

This detailed methodology and structured approach ensure that we understand how to remove duplicates from a sorted linked list effectively.