Skip to content
Related Articles

Related Articles

Delete a Linked List node at a given position

Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 26 May, 2022
 

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
 

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. So if positions are not zero, we run a loop position-1 times and get a pointer to the previous node.

Below is the implementation of the above idea.

C++




// 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
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 deleteNode(self, position):
        if self.head is None:
            return
        if position == 0:
            self.head = self.head.next
            return self.head
        index = 0
        current = self.head
        prev = self.head
        temp = self.head
        while current is not None:
            if index == position:
                temp = current.next
                break
            prev = current
            current = current.next
            index += 1
        prev.next = temp
        return prev
 
    # 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.deleteNode(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--
 10-> 20-> 30-> 40-> 50-> 60->NULL      

Linked List after deletion at position 0
Element deleted is : 10

Updated Linked List is : 
 20-> 30-> 40-> 50-> 60->NULL

Linked List after deletion at position 2
Element deleted is : 40

Updated Linked List is : 
 20-> 30-> 50-> 60->NULL

Complexity Analysis : 

Best Case : O(1) if given position is 1 

Average  & Worst Case : O(N)  if position given is size-1 then need to traverse till position not found.

Space Complexity : O(1) no extra any space is required

Thanks to Hemanth Kumar for suggesting initial solution. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!