﻿ Rust Program: Remove duplicates from singly linked list

# Rust Program: Remove duplicates from singly linked list

## Rust Linked Lists: Exercise-9 with Solution

Write a Rust program to remove duplicates from an unsorted singly linked list.

Sample Solution:

Rust Code:

``````use std::collections::HashSet;

// Define the singly linked list node
pub struct Node {
val: T,
next: Option>>,
}

}

// Function to remove duplicates from the linked list
pub fn remove_dupes(&mut self) {
// Create a HashSet to store unique elements
let mut set = HashSet::new();
// Initialize a mutable reference to the head of the linked list
let mut current = &mut self.head;

// Iterate through the linked list
while let Some(mut node) = current.take() {
// If the current node's value is found in the HashSet, remove it
if set.contains(&node.val) {
*current = node.next.take();
} else {
// Insert the current node's value into the HashSet
set.insert(node.val.clone());
// Re-insert the current node back into the linked list
*current = Some(node);
// Move the reference to the next node
current = &mut current.as_mut().unwrap().next;
}
}
}
}

fn main() {
// Example usage
let mut list = LinkedList {
val: 1,
next: Some(Box::new(Node {
val: 2,
next: Some(Box::new(Node {
val: 1,
next: None,
})),
})),
})),
};
// Remove duplicates from the list
list.remove_dupes();

// Print the modified list
while let Some(node) = current {
println!("{}", node.val);
current = &node.next;
}
}
```
```

Output:

```1
2
```

Explanation:

Here is a brief explanation of the above Rust code:

• The Node<T> struct represents a node in a singly linked list, containing a value of type T and an optional pointer to the next node.
• The LinkedList<T> struct represents the linked list itself, containing an optional pointer to the head node.
• remove_dupes Method:
• This method belongs to the "LinkedList" struct and is used to remove duplicate elements from the linked list.
• It utilizes a HashSet to keep track of unique elements encountered so far.
• It iterates through the linked list using mutable references and removes duplicate nodes by updating pointers accordingly.
• Main Function:
• In the main function, an example linked list is created with some duplicate elements.
• The "remove_dupes()" method is called to remove duplicates from the list.
• Finally, the modified list is printed to verify that duplicates have been removed.
• Explanation of Usage:
• The "remove_dupes()" method efficiently removes duplicates from the linked list while preserving the order of elements.
• It achieves this by using a HashSet to track unique elements and updating the linked list in-place.
• This approach has a time complexity of O(n), where n is the number of elements in the linked list.

Rust Code Editor:

What is the difficulty level of this exercise?

Test your Programming skills with w3resource's quiz.

﻿