# Delete a Linked List node at a given position

• Difficulty Level : Easy
• Last Updated : 28 Jun, 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

Input: position = 0, Linked List = 8->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 ` `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` `#include`   `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;inext;` `        ``}` `        ``// 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

 ``

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 :