﻿ Rust Program: Delete Node by position in singly linked list

# Rust Program: Deleting Node by position from singly linked list

## Rust Linked Lists: Exercise-5 with Solution

Write a Rust program to delete a node from a singly linked list by position.

Sample Solution:

Rust Code:

``````// Define the Node struct to represent individual nodes in the linked list
#[derive(Debug)]
struct Node<T> {
data: T,
next: Option<Box<Node<T>>>, // Pointer to the next node
}

}

// Method to delete a node from the linked list by position
fn delete_node_by_position(&mut self, position: usize) {
let mut count = 0; // Initialize a counter to keep track of the current position

while let Some(node) = current {
// Check if the current node is the one to be deleted
if position == 0 {
// If the first node is to be deleted, update the head to the next node
return; // Exit the function
}

// Check if the next node exists and is at the position to be deleted
if count == position - 1 {
// If the next node is to be deleted, update the next pointer of the current node
node.next = node.next.take().unwrap().next;
return; // Exit the function
}

// Move to the next node
current = &mut node.next;
count += 1; // Increment the counter
}
}
}

fn main() {
// Create a new linked list
let mut list = SinglyLinkedList {
head: Some(Box::new(Node { data: 1, next: None })),
};

// Insert some nodes into the linked list

// Print the original linked list

// Delete a node from the linked list by position
list.delete_node_by_position(2); // Delete node at position 2 (3rd node)

// Print the updated linked list
}
```
```

Output:

```Original Linked List: Some(Node { data: 5, next: Some(Node { data: 4, next: Some(Node { data: 3, next: Some(Node { data: 2, next: Some(Node { data: 1, next: None }) }) }) }) })
Linked List after deletion: Some(Node { data: 5, next: Some(Node { data: 4, next: Some(Node { data: 2, next: Some(Node { data: 1, next: None }) }) }) })
```

Explanation:

Here is a brief explanation of the above Rust code:

• Node struct: Represents individual nodes in the linked list. Each node contains data (data) and a pointer to the next node (next), which is an 'Option' wrapping a 'Box' pointing to another 'Node'.
• SinglyLinkedList struct: Represents the linked list itself. It contains a pointer to the head of the linked list (head), which is an 'Option' wrapping a 'Box' pointing to the first Node.
• impl block for SinglyLinkedList: Implements methods for the linked list. In this case, it defines a method "delete_node_by_position()" to remove a node from the linked list by its position.
• delete_node_by_position method: Removes a node from the linked list based on its position. It traverses the list until it reaches the specified position, then adjusts the pointers to bypass the node to be deleted.
• main function: Entry point of the program. It shows the usage of the linked list by creating a list, inserting nodes, deleting a node by position, and printing the original and updated lists.

Rust Code Editor:

What is the difficulty level of this exercise?

Test your Programming skills with w3resource's quiz.

﻿