Delete a Linked List node at a given position

Given a singly linked list and a position, delete a linked list node at the given position.

Example:

Input: position = 1, Linked List = 8->2->3->1->7
Output: Linked List =  8->3->1->7

Input: position = 0, Linked List = 8->2->3->1->7
Output: Linked List = 2->3->1->7

Approach:

If the node to be deleted is the root, simply delete it. To delete a middle node, we must have a pointer to the node previous to the node to be deleted.

Here are the algorithmic steps to delete a linked list node at a given position:

1. Input: A pointer to the head node of the linked list and the value to be deleted.
2. If the linked list is empty, return NULL.
3. If the node to be deleted is the head node, set the head node to the next node and delete the original head node.
4. Otherwise, traverse the linked list from the head node until the node to be deleted is found.
5. If the node to be deleted is not found, return NULL.
6. Otherwise, set the previous node’s next pointer to the node after the node to be deleted.
7. Delete the node to be deleted.
8. Return the head node of the linked list.

Below is the implementation of the above idea.

C++14

// A complete working C++ program to delete
// a node in a linked list at a given position
#include <iostream>
using namespace std;

// A linked list node
class Node {
public:
    int data;
    Node* next;
};

// Given a reference (pointer to pointer) to
// the head of a list and an int inserts a
// new node on the front of the list.
void push(Node** head_ref, int new_data)
{
    Node* new_node = new Node();
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}

// Given a reference (pointer to pointer) to
// the head of a list and a position, deletes
// the node at the given position
void deleteNode(Node** head_ref, int position)
{

    // If linked list is empty
    if (*head_ref == NULL)
        return;

    // Store head node
    Node* temp = *head_ref;

    // If head needs to be removed
    if (position == 0) {

        // Change head
        *head_ref = temp->next;

        // Free old head
        free(temp);
        return;
    }

    // Find previous node of the node to be deleted
    for (int i = 0; temp != NULL && i < position - 1; i++)
        temp = temp->next;

    // If position is more than number of nodes
    if (temp == NULL || temp->next == NULL)
        return;

    // Node temp->next is the node to be deleted
    // Store pointer to the next of node to be deleted
    Node* next = temp->next->next;

    // Unlink the node from linked list
    free(temp->next); // Free memory

    // Unlink the deleted node from list
    temp->next = next;
}

// This function prints contents of linked
// list starting from the given node
void printList(Node* node)
{
    while (node != NULL) {
        cout << node->data << " ";
        node = node->next;
    }
}

// Driver code
int main()
{

    // Start with the empty list
    Node* head = NULL;

    push(&head, 7);
    push(&head, 1);
    push(&head, 3);
    push(&head, 2);
    push(&head, 8);

    cout << "Created Linked List: ";
    printList(head);
    deleteNode(&head, 4);
    cout << "\nLinked List after Deletion at position 4: ";
    printList(head);
    return 0;
}

// This code is contributed by premsai2030

C

// Simple C code to delete node at particular position

#include <stdio.h>
#include <stdlib.h>

void insert(int);
void display_List();
void delete (int);

struct node // Structure declaration
{
    int data;
    struct node* next; // Self referral pointer
}* head = NULL,
   *tail
   = NULL; // Initial value of Head and Tail pointer is NULL

void delete (int pos)
{
    struct node* temp = head; // Creating a temporary
                              // variable pointing to head
    int i;
    if (pos == 0) {
        printf("\nElement deleted is : %d\n", temp->data);
        head = head->next; // Advancing the head pointer
        temp->next = NULL;
        free(temp); // Node is deleted
    }
    else {
        for (i = 0; i < pos - 1; i++) {
            temp = temp->next;
        }
        // Now temp pointer points to the previous node of
        // the node to be deleted
        struct node* del
            = temp->next; // del pointer points to the node
                          // to be deleted
        temp->next = temp->next->next;
        printf("\nElement deleted is : %d\n", del->data);
        del->next = NULL;
        free(del); // Node is deleted
    }
    printf("\nUpdated Linked List is : \n");
    display_List();
    return;
}

void insert(int value)
{
    struct node* newnode; // Creating a new node
    newnode = (struct node*)malloc(
        sizeof(struct node)); // Allocating dynamic memory

    newnode->data = value; // Assigning value to newnode
    newnode->next = NULL;

    if (head == NULL) // Checking if List is empty
    {
        head = newnode;
        tail = newnode;
    }
    else // If not empty then...
    {
        tail->next = newnode;
        tail = newnode; // Updating the tail node with each
                        // insertion
    }
    return;
}

void display_List()
{
    struct node* temp; // Creating a temporary pointer to
                       // the structure
    temp = head; // temp points to head;
    while (temp != NULL) {
        if (temp->next == NULL) {
            printf(" %d->NULL", temp->data);
        }
        else {
            printf(" %d->", temp->data);
        }
        temp = temp->next; // Traversing the List till end
    }
    printf("\n");
    return;
}
// --Driver Code--
int main()
{
    insert(10);
    insert(20);
    insert(30);
    insert(40);
    insert(50);
    insert(60);
    printf("\n--Created Linked List--\n");
    display_List();
    printf("\nLinked List after deletion at position 0");
    delete (0); // List indexing starts from 0
    printf("\nLinked List after deletion at position 2");
    delete (2);
    return 0;
}
// This code is contributed by Sanjeeban Mukhopadhyay.

Java

// A complete working Java program to delete a node in a
// linked list at a given position
import java.io.*;
class LinkedList {
    Node head; // head of list

    /* Linked list Node*/
    class Node {
        int data;
        Node next;
        Node(int d)
        {
            data = d;
            next = null;
        }
    }

    /* Inserts a new Node at front of the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    /* Given a reference (pointer to pointer) to the head of
       a list
       and a position, deletes the node at the given
       position */
    void deleteNode(int position)
    {
        // If linked list is empty
        if (head == null)
            return;

        // Store head node
        Node temp = head;

        // If head needs to be removed
        if (position == 0) {
            head = temp.next; // Change head
            return;
        }

        // Find previous node of the node to be deleted
        for (int i = 0; temp != null && i < position - 1;
             i++)
            temp = temp.next;

        // If position is more than number of nodes
        if (temp == null || temp.next == null)
            return;

        // Node temp->next is the node to be deleted
        // Store pointer to the next of node to be deleted
        Node next = temp.next.next;

        temp.next
            = next; // Unlink the deleted node from list
    }

    /* This function prints contents of linked list starting
       from the given node */
    public void printList()
    {
        Node tnode = head;
        while (tnode != null) {
            System.out.print(tnode.data + " ");
            tnode = tnode.next;
        }
    }

    /* Driver program to test above functions. Ideally this
       function should be in a separate user class.  It is
       kept here to keep code compact */
    public static void main(String[] args)
    {
        /* Start with the empty list */
        LinkedList llist = new LinkedList();

        llist.push(7);
        llist.push(1);
        llist.push(3);
        llist.push(2);
        llist.push(8);

        System.out.println("\nCreated Linked list is: ");
        llist.printList();

        llist.deleteNode(4); // Delete node at position 4

        System.out.println(
            "\nLinked List after Deletion at position 4: ");
        llist.printList();
    }
}

Python3

# Python program to delete a node in a linked list
# at a given position

# Node class


class Node:

    # Constructor to initialize the node object
    def __init__(self, data):
        self.data = data
        self.next = None


class LinkedList:

    # Constructor to initialize head
    def __init__(self):
        self.head = None

    # Function to insert a new node at the beginning
    def push(self, new_data):
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node

    # Given a reference to the head of a list
    # and a position, delete the node at a given position
    # This delete function code is contributed by Arabin Islam
    def deleteNodeAtGivenPosition(self, position):
        if self.head is None:
            return
        index = 0
        current = self.head
        while current.next and index < position:
            previous = current
            current = current.next
            index += 1
        if index < position:
            print("\nIndex is out of range.")
        elif index == 0:
            self.head = self.head.next
        else:
            previous.next = current.next
            # current = None #Optional statement

    # Utility function to print the LinkedList

    def printList(self):
        temp = self.head
        while(temp):
            print(" %d " % (temp.data), end=" ")
            temp = temp.next


# Driver program to test above function
llist = LinkedList()
llist.push(7)
llist.push(1)
llist.push(3)
llist.push(2)
llist.push(8)

print("Created Linked List: ")
llist.printList()
llist.deleteNodeAtGivenPosition(4)
print("\nLinked List after Deletion at position 4: ")
llist.printList()

# This code is contributed by Nikhil Kumar Singh(nickzuck_007)

C#

// A complete working C# program to delete
// a node in a linked list at a given position
using System;

class GFG {

    // Head of list
    Node head;

    // Linked list Node
    public class Node {
        public int data;
        public Node next;

        public Node(int d)
        {
            data = d;
            next = null;
        }
    }

    // Inserts a new Node at front of the list.
    public void Push(int new_data)
    {

        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);

        /* 3. Make next of new Node as head */
        new_node.next = head;

        /* 4. Move the head to point to new Node */
        head = new_node;
    }

    // Given a reference (pointer to pointer)
    // to the head of a list and a position,
    // deletes the node at the given position
    void deleteNode(int position)
    {

        // If linked list is empty
        if (head == null)
            return;

        // Store head node
        Node temp = head;

        // If head needs to be removed
        if (position == 0) {

            // Change head
            head = temp.next;
            return;
        }

        // Find previous node of the node to be deleted
        for (int i = 0; temp != null && i < position - 1;
             i++)
            temp = temp.next;

        // If position is more than number of nodes
        if (temp == null || temp.next == null)
            return;

        // Node temp->next is the node to be deleted
        // Store pointer to the next of node to be deleted
        Node next = temp.next.next;

        // Unlink the deleted node from list
        temp.next = next;
    }

    // This function prints contents of
    // linked list starting from the
    // given node
    public void printList()
    {
        Node tnode = head;
        while (tnode != null) {
            Console.Write(tnode.data + " ");
            tnode = tnode.next;
        }
    }

    // Driver code
    public static void Main(String[] args)
    {

        // Start with the empty list
        GFG llist = new GFG();

        llist.Push(7);
        llist.Push(1);
        llist.Push(3);
        llist.Push(2);
        llist.Push(8);

        Console.WriteLine("\nCreated Linked list is: ");
        llist.printList();

        // Delete node at position 4
        llist.deleteNode(4);

        Console.WriteLine("\nLinked List after "
                          + "Deletion at position 4: ");
        llist.printList();
    }
}

// This code is contributed by Rajput-Ji

Javascript

<script>

// A complete working javascript program to
// delete a node in a linked list at a
// given position

// head of list
var head;

/* Linked list Node */
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}

/* Inserts a new Node at front of the list. */
function push(new_data)
{

    /*
     * 1 & 2: Allocate the Node & Put in the data
     */
    var new_node = new Node(new_data);

    /* 3. Make next of new Node as head */
    new_node.next = head;

    /* 4. Move the head to point to new Node */
    head = new_node;
}

/*
 * Given a reference (pointer to pointer) to the
 * head of a list and a position,
 * deletes the node at the given position
 */
function deleteNode(position)
{

    // If linked list is empty
    if (head == null)
        return;

    // Store head node
    var temp = head;

    // If head needs to be removed
    if (position == 0)
    {

        // Change head
        head = temp.next;
        return;
    }

    // Find previous node of the node to be deleted
    for(i = 0; temp != null && i < position - 1; i++)
        temp = temp.next;

    // If position is more than number of nodes
    if (temp == null || temp.next == null)
    return;

    // Node temp->next is the node to be deleted
    // Store pointer to the next of node to be deleted
    var next = temp.next.next;

    // Unlink the deleted node from list
    temp.next = next;
}

/*
* This function prints contents of linked
* list starting from the given node
*/
function printList()
{
    var tnode = head;
    while (tnode != null)
    {
        document.write(tnode.data + " ");
        tnode = tnode.next;
    }
}

/*
* Driver program to test above functions.
* Ideally this function should be in a
* separate user class. It is kept here
* to keep code compact
*/

/* Start with the empty list */
push(7);
push(1);
push(3);
push(2);
push(8);

document.write("Created Linked list is: <br/>");
printList();

// Delete node at position 4
deleteNode(4);

document.write("<br/>Linked List after " +
               "Deletion at position 4: <br/>");
printList();

// This code is contributed by todaysgaurav

</script>

Output

Created Linked List: 8 2 3 1 7 
Linked List after Deletion at position 4: 8 2 3 1 

Time Complexity: 

• Best Case: O(1) if given position is 1 
• Average  & Worst Case: O(N) where N is the length of the linked list. This is because in the worst case, we need to traverse the entire linked list to find the node to be deleted.

Auxiliary Space: O(1) as we are only using a constant amount of extra space for temporary variables and pointers, regardless of the size of the linked list. Specifically, we only need to allocate memory for a few temporary pointers (e.g., current, temp) and the new head pointer if the original head is deleted. The memory for the deleted node(s) is also freed as soon as it is deleted