## Related Articles

• Write an Interview Experience

# Delete a Linked List node at a given position

• Difficulty Level : Easy
• Last Updated : 17 Oct, 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++14

 `// 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; 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 < 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

 ``

Output

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

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