Why is deleting in a Singly Linked List O(1)?
Last Updated :
09 Mar, 2023
How does deleting a node in Singly Linked List work?
To delete a node from a linked list we need to break the link between that node and the one pointing to that node. Assume node X needs to be deleted and node Y is the one pointing to X. So, we will need to break the link between X and Y and Y will point to the node which was being pointed by X.
Types of Deletion of a node from Linked List
There can be three types of deletions:
- Deletion from the beginning of the linked list
- Deletion from the end of the linked list
- Deletion from in between the beginning and the end.
All the cases do not take O(1) time. Check the below section to find the time complexities of different operations.
Time Complexities of different deletion operations
Deletion from the beginning:
- Point head to the next node
- Time Complexity: O(1)
Deletion from the end:
- Traverse to the second last element
- Change its next pointer to NULL.
- Time Complexity: O(N)
Delete from the middle of a linked list
- Traverse to the element which is just before the element to be deleted
- Change the next pointers to exclude the node from the list
- Time Complexity: O(N)
When Deletion in a Singly Linked List takes O(1) time?
There are 3 cases when deleting in a singly linked list is O(1), because we do not have to traverse the list.
First case: When we have the pointer pointing to the node which needs to be deleted, let’s call it prev. So, we have to do,
- curr = prev->next
- prev->next = curr->next
- curr->next = NULL
- delete curr
Since curr is the node that is deleted from the singly linked list.
Second case: When we have to delete the first/start/head node, let’s call it head. So, we have to do,
Hence head is pointing to the next node.
Third case: When we have to delete the last/end/tail node, let’s call it tail. So, we have to do,
This is only possible if we maintain an extra pointer except the head i.e., tail for referencing the last node of the linked list. But we can do this only once because after doing this we lose the reference of the last node and there is no way to find the reference of the new last node in O(1) in a singly linked list. In a doubly linked list, it is possible as it contains the previous pointer.
Complexities of deletion from Linked List
Below is the implementation of different deletion operations in a singly linked list:
C++
#include <iostream>
using namespace std;
class Node {
public :
int data;
Node* next;
Node( int d)
{
data = d;
next = NULL;
}
};
void deleteFromStart(Node*& head)
{
head = head->next;
}
void deleteGivenNode(Node*& head, int val)
{
if (head->data == val) {
head = head->next;
}
Node *temp = head, *prev = NULL;
while (temp->data != val) {
prev = temp;
temp = temp->next;
}
prev->next = temp->next;
}
void deleteFromEnd(Node* head)
{
Node* temp = head;
while (temp->next->next != NULL) {
temp = temp->next;
}
temp->next = NULL;
}
void printList(Node* head)
{
Node* temp = head;
while (temp != NULL) {
cout << temp->data << " " ;
temp = temp->next;
}
cout << endl;
}
int main()
{
Node* head = new Node(10);
Node* second = new Node(20);
Node* third = new Node(30);
Node* fourth = new Node(40);
head->next = second;
second->next = third;
third->next = fourth;
cout << "Original list: " ;
printList(head);
deleteFromStart(head);
cout << "List after deleting the starting node: " ;
printList(head);
deleteFromEnd(head);
cout << "List after deleting the ending node: " ;
printList(head);
deleteGivenNode(head, 30);
cout << "List after deleting the given node: " ;
printList(head);
}
|
Java
class Node {
public int data;
public Node next;
public Node( int d) {
data = d;
next = null ;
}
}
public class Main {
public static Node deleteFromStart(Node head) {
head = head.next;
return head;
}
public static void deleteGivenNode(Node head, int val) {
if (head.data == val) {
head = head.next;
}
Node temp = head, prev = null ;
while (temp.data != val) {
prev = temp;
temp = temp.next;
}
prev.next = temp.next;
}
public static void deleteFromEnd(Node head) {
Node temp = head;
while (temp.next.next != null ) {
temp = temp.next;
}
temp.next = null ;
}
public static void printList(Node head) {
Node temp = head;
while (temp != null ) {
System.out.print(temp.data + " " );
temp = temp.next;
}
System.out.println();
}
public static void main(String[] args) {
Node head = new Node( 10 );
Node second = new Node( 20 );
Node third = new Node( 30 );
Node fourth = new Node( 40 );
head.next = second;
second.next = third;
third.next = fourth;
System.out.print( "Original list: " );
printList(head);
head = deleteFromStart(head);
System.out.print( "List after deleting the starting node: " );
printList(head);
deleteFromEnd(head);
System.out.print( "List after deleting the ending node: " );
printList(head);
deleteGivenNode(head, 30 );
System.out.print( "List after deleting the given node: " );
printList(head);
}
}
|
Python3
class Node:
def __init__( self ,val):
self .val = val
self . next = None
def deleteFromStart(head):
if head ! = None :
head = head. next
return head
def deleteGivenNode(head,val):
if head.val = = val: head = head. next
curr = head
prev = None
while curr and curr.val ! = val:
prev = curr
curr = curr. next
prev. next = curr. next
def deleteFromEnd(head):
curr = head
while curr. next and curr. next . next ! = None :
curr = curr. next
curr. next = None
def printList(head):
if head = = None :
print ( 'List is Empty' )
return
curr = head
while curr ! = None :
print (curr.val,end = ' ' )
curr = curr. next
print ()
head = Node( 10 )
second = Node( 20 )
third = Node( 30 )
fourth = Node( 40 )
head. next = second
second. next = third
third. next = fourth
print ( "Original list: " )
printList(head)
head = deleteFromStart(head)
print ( "List after deleting the starting node: " )
printList(head)
deleteFromEnd(head)
print ( "List after deleting the ending node: " )
printList(head)
deleteGivenNode(head, 30 )
print ( "List after deleting the given node: " )
printList(head)
|
C#
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
class Node {
public int data;
public Node next;
public Node( int d) {
data = d;
next = null ;
}
}
class HelloWorld {
public static Node deleteFromStart(Node head) {
head = head.next;
return head;
}
public static void deleteGivenNode(Node head, int val) {
if (head.data == val) {
head = head.next;
}
Node temp = head, prev = null ;
while (temp.data != val) {
prev = temp;
temp = temp.next;
}
prev.next = temp.next;
}
public static void deleteFromEnd(Node head) {
Node temp = head;
while (temp.next.next != null ) {
temp = temp.next;
}
temp.next = null ;
}
public static void printList(Node head) {
Node temp = head;
while (temp != null ) {
Console.Write(temp.data + " " );
temp = temp.next;
}
Console.WriteLine();
}
static void Main() {
Node head = new Node(10);
Node second = new Node(20);
Node third = new Node(30);
Node fourth = new Node(40);
head.next = second;
second.next = third;
third.next = fourth;
Console.Write( "Original list: " );
printList(head);
head = deleteFromStart(head);
Console.Write( "List after deleting the starting node: " );
printList(head);
deleteFromEnd(head);
Console.Write( "List after deleting the ending node: " );
printList(head);
deleteGivenNode(head, 30);
Console.Write( "List after deleting the given node: " );
printList(head);
}
}
|
Javascript
<script>
class Node {
constructor(val){
this .data = val;
this .next = null ;
}
}
function deleteFromStart(head)
{
head = head.next;
return head;
}
function deleteGivenNode(head, val)
{
if (head.data == val) {
head = head.next;
}
let temp = head;
let prev = null ;
while (temp.data != val) {
prev = temp;
temp = temp.next;
}
prev.next = temp.next;
}
function deleteFromEnd(head)
{
let temp = head;
while (temp.next.next != null ) {
temp = temp.next;
}
temp.next = null ;
}
function printList(head)
{
let temp = head;
while (temp != null ) {
document.write(temp.data + " " );
temp = temp.next;
}
document.write( "\n" );
}
let head = new Node(10);
let second = new Node(20);
let third = new Node(30);
let fourth = new Node(40);
head.next = second;
second.next = third;
third.next = fourth;
document.write( "Original list: " );
printList(head);
head = deleteFromStart(head);
document.write( "List after deleting the starting node: " );
printList(head);
deleteFromEnd(head);
document.write( "List after deleting the ending node: " );
printList(head);
deleteGivenNode(head, 30);
document.write( "List after deleting the given node: " );
printList(head);
</script>
|
Output
Original list: 10 20 30 40
List after deleting the starting node: 20 30 40
List after deleting the ending node: 20 30
List after deleting the given node: 20
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...