Skip to content
Related Articles

Related Articles

Delete a Linked List node at a given position

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 26 Jul, 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.

Complete Interview Preparation - GFG

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 - 2; 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 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 == 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.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: 8 2 3 1 7 
Linked List after Deletion at position 4: 8 2 3 1 

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!