Linked List Deletion (Deleting a key at a given position)

Linked lists are fundamental data structures that are essential in computer science. The deletion of a node at a particular point is a fundamental and often-used operation on linked lists. In this post, we will dig into the complexities of linked list deletion, investigating its relevance, underlying concepts, and a comprehensive Python implementation.

A linked list is a linear data structure made up of nodes, each of which contains a data element as well as a reference (or link) to the next node in the series. The last node usually refers to None, indicating the conclusion of the list. In contrast to arrays, this dynamic structure provides advantages such as efficient insertions and removals at arbitrary points.

The Importance of Removal

Deletion of a linked list is critical for preserving the data structure's integrity and performance. Removing a node at a certain place requires altering the linkages between nodes to maintain the logical flow of data. Because linked lists may remove nodes dynamically, they can adapt to changing requirements, making them an effective tool for handling evolving datasets.

Deletion at a Given Position: A Step-by-Step Approach

1. Deleting the Head:

The first possibility to explore is deleting the linked list's head. If the initial node is to be eliminated, changing the head to point to the next node effectively removes it from the list. This procedure has a temporal complexity of O(1) and is thus very efficient.

Time Complexity: O(1) - constant time, as it involves a simple pointer update.

Space Complexity: O(1) - constant space, as no additional data structures are used.

Implementation

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* next;
};
void deleteHead(struct Node** head) {
    if (*head == NULL) {
        printf("List is empty. Deletion failed.\n");
        return;
    }
    struct Node* temp = *head;
    *head = (*head)->next;
    free(temp); 
    printf("Head deleted successfully.\n");
}
void displayList(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}
int main() {
    struct Node* head = NULL;
    for (int i = 5; i >= 1; i--) {
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->data = i;
        newNode->next = head;
        head = newNode;
    }
    printf("Original Linked List: ");
    displayList(head);
    deleteHead(&head);
    printf("Linked List after Head Deletion: ");
    displayList(head);
    return 0;
}

This implementation includes:

The struct Node provides the structure of a linked list node, which includes an integer (data) and a reference to the next node (next).
The deleteHead method accepts a double pointer to the linked list's head. If the list is not empty, it changes the head to refer to the next node and releases the memory held by the previous head node.
The displayList function traverses and prints the linked list's items.
The main function inserts nodes into the linked list for demonstration purposes and displays the original and updated linked lists.

Output

Linked List Deletion (Deleting a key at a given position)

2. Delete Other Nodes

A more detailed approach is necessary for nodes other than the head. The algorithm comprises traversing the list until the target location is reached, then diverting the following node's pointer to bypass the node to be destroyed.

Time Complexity: O(n) - linear time, where n is the number of nodes in the linked list.

Space Complexity: O(1) - constant space, as the algorithm uses a fixed amount of additional memory.

Implementation

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* next;
};
void deleteAtPosition(struct Node** head, int position) {
    if (*head == NULL) {
        printf("List is empty. Deletion failed.\n");
        return;
    }
    struct Node* current = *head;
    struct Node* prev = NULL;
    int count = 0;
    while (current != NULL && count < position) {
        prev = current;
        current = current->next;
        count++;
    }
    if (current == NULL) {
        printf("Position %d not found in the list. Deletion failed.\n", position);
        return;
    }
    if (prev != NULL) {
        prev->next = current->next;
        free(current); 
        printf("Node at position %d deleted successfully.\n", position);
    } else {
        *head = current->next;
        free(current); 
        printf("Node at position %d (head) deleted successfully.\n", position);
    }
}
void displayList(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}
int main() {
    struct Node* head = NULL;
    for (int i = 5; i >= 1; i--) {
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->data = i;
        newNode->next = head;
        head = newNode;
    }
    printf("Original Linked List: ");
    displayList(head);
    int positionToDelete = 2;
    deleteAtPosition(&head, positionToDelete);
    printf("Linked List after Deleting Node at Position %d: ", positionToDelete);
    displayList(head);
    return 0;
}

This implementation includes:

The deleteAtPosition function accepts a double reference to the linked list's head and the location to be deleted.
It explores the list until it reaches the desired place, modifying the next node's pointer to skip the current node.
The displayList method is used to output the linked list's items.
Nodes are placed into the linked list for demonstration purposes in the main function, and a node at a certain point is removed.

Output:

3. Handling Edge Cases

Edge situations must be considered in robust linked list deletion solutions. These include attempting to delete a node from an empty list, attempting to delete a node at a non-existent location, and dealing with deletions that extend past the end of the list.

Time Complexity: O(1) - constant time, as it involves basic conditional checks.

Space Complexity: O(1) - constant space, as no additional memory is used.

Implementation

#include <stdio.h>
#include <stdlib.h>
struct Node {
    int data;
    struct Node* next;
};
void deleteAtPosition(struct Node** head, int position) {
    if (*head == NULL) {
        printf("List is empty. Deletion failed.\n");
        return;
    }
    struct Node* current = *head;
    struct Node* prev = NULL;
    int count = 0;
    while (current != NULL && count < position) {
        prev = current;
        current = current->next;
        count++;
    }
    if (current == NULL) {
        printf("Position %d not found in the list. Deletion failed.\n", position);
        return;
    }
    if (prev != NULL) {
        prev->next = current->next;
        free(current); 
        printf("Node at position %d deleted successfully.\n", position);
    } else {
        *head = current->next;
        free(current); 
        printf("Node at position %d (head) deleted successfully.\n", position);
    }
}
void displayList(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}
int main() {
    struct Node* head = NULL;
    printf("Original Linked List: ");
    displayList(head);
    deleteAtPosition(&head, 2);
    for (int i = 5; i >= 1; i--) {
        struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->data = i;
        newNode->next = head;
        head = newNode;
    }
    printf("Updated Linked List: ");
    displayList(head);
    deleteAtPosition(&head, 10);
    deleteAtPosition(&head, 5);
    printf("Final Linked List: ");
    displayList(head);
    return 0;
}

In this improved version:

The program begins by attempting to remove a node from an empty list, then inserts nodes as a demonstration.
It demonstrates attempting to remove a node at an invalid point and dealing with deletions that extend past the end of the list.
Proper messages are shown for each circumstance, indicating whether or not the deletion was successful.

Output:

Conclusion

Finally, linked list deletion at a specific point is a critical operation in the world of data structures. Understanding the ideas underlying this procedure, such as pointer updates and managing exceptional circumstances, is essential for any programmer or computer science enthusiast. Linked lists are a versatile and strong tool because of their ability to manage data dynamically through efficient deletion. We obtain insights into the underlying workings of these dynamic structures by investigating the complexities of linked list deletion, opening the door for more advanced data manipulation tasks. Mastering linked list deletion is an important step in your journey through the world of computer science, whether you are a newbie learning the ropes or an experienced developer honing your abilities.

Next TopicMastering Bracket Problems for Competitive Programming

← prev next →