Program to delete all even nodes from a Singly Linked List

30 Jun, 2022
Given a singly linked list containing N nodes, the task is to delete all the even nodes from the list. 
Examples:  
Input: LL = 1 -> 4 -> 3 -> 18 -> 19 Output: 1 -> 3 -> 19Input: LL = 5 -> 3 -> 6 -> 8 -> 4 -> 1 -> 2 -> 9 Output: 5 -> 3 -> 1 -> 9  
Approach 1: 
The idea is to traverse the nodes of the singly linked list one by one and get the pointer of the nodes having even data. Delete those nodes by following the approach used in this post.
Below is the implementation of the above idea: 
C++
Java
Python3
C#
Javascript
// C++ implementation to delete all// even nodes from the singly linked list #include <bits/stdc++.h>using namespace std; // Node of the singly linked liststruct Node{    int data;    struct Node* next;}; // Function to insert a node at// the beginning of the singly// Linked Listvoid push(struct Node** head_ref,          int new_data){    struct Node* new_node        = (struct Node*)malloc(            sizeof(                struct Node));     new_node->data = new_data;    new_node->next = (*head_ref);    (*head_ref) = new_node;} // Function to delete a node in a// singly Linked List.// head_ref --> Pointer to head// node pointer.// key --> Node to be deletedvoid deleteNode(struct Node** head_ref,                int key){    // Store head node    struct Node *temp = *head_ref,                *prev;     // If head node itself holds    // the key to be deleted    if (temp != NULL        && temp->data == key) {        // Changed head        *head_ref = temp->next;        return;    }     // Search for the key to be    // deleted, keep track of the    // previous node as we need    // to change 'prev->next'    while (temp != NULL           && temp->data != key) {        prev = temp;        temp = temp->next;    }     // If key was not present    // in linked list    if (temp == NULL)        return;     // Unlink the node from    // linked list    prev->next = temp->next;     } // Function to delete all the// even nodes from the// singly linked listvoid deleteEvenNodes(Node** head_ref){    Node* ptr = *head_ref;    // Node* next;     while (ptr != NULL) {        // next = ptr->next;        // If true, delete node 'ptr'        if (ptr->data % 2 == 0)            deleteNode(head_ref,                       ptr->data);        ptr = ptr->next;    }} // This function prints contents// of linked list starting from// the given nodevoid printList(struct Node* node){    while (node != NULL) {        printf(" %d -> ", node->data);        node = node->next;    }} // Driver codeint main(){    // Start with the empty list    Node* head = NULL;    push(&head, 19);    push(&head, 18);    push(&head, 3);    push(&head, 4);    push(&head, 1);     printf("Initial List: ");    printList(head);     deleteEvenNodes(&head);     printf("\nFinal List: ");    printList(head);}
// Java implementation to delete all// even nodes from the singly linked listclass LinkedList{     // head of listNode head; // Linked list Nodeclass Node{    int data;    Node next;    Node(int d)    {        data = d;        next = null;    }} // Function to insert a node at// the beginning of the singly// Linked Listpublic void push(int new_data){    Node new_node = new Node(new_data);    new_node.next = head;    head = new_node;} // Function to delete a node in a// singly Linked List.void deleteNode(int key){         // Store head node    Node temp = head, prev = null;     // If head node itself holds the    // key to be deleted    if (temp != null && temp.data == key)    {                 // Changed head        head = temp.next;        return;    }     // Search for the key to be deleted,    // keep track of the previous node    // as we need to change temp.next    while (temp != null && temp.data != key)    {        prev = temp;        temp = temp.next;    }     // If key was not present in linked list    if (temp == null) return;     // Unlink the node from linked list    prev.next = temp.next;} // Function to delete all the nodes// from linked list containing// even numbers.void deleteEvenNodes(){    Node ptr = head;     // loop to iterate the linked list    while(ptr != null)    {         // If containing element is even        if(ptr.data % 2 == 0)        {                         // Delete the node            deleteNode(ptr.data);        }        ptr = ptr.next;    }} // This function prints contents of linked// list starting from the given nodepublic void printList(){    Node ptr = head;    while (ptr != null)    {        System.out.print(ptr.data + "-> ");        ptr = ptr.next;    }} // Driver codepublic static void main(String[] args){    LinkedList head = new LinkedList();     head.push(19);    head.push(18);    head.push(3);    head.push(4);    head.push(1);     System.out.print("\nInitial List: ");    head.printList();     head.deleteEvenNodes();     System.out.print("\nFinal List: ");    head.printList();}} // This code is contributed by Amit Mangal
# Python3 implementation to delete all# even nodes from the singly linked list# Node classclass Node:         # Function to initialize the node object    def __init__(self, data):                 # Assign data        self.data = data                 # Initialize        # next as null        self.next = None     # Linked List Classclass LinkedList:         # Function to initialize the    # LinkedList class.    def __init__(self):         # Initialize head as None        self.head = None     # This function insert a new node at    # the beginning of the linked list    def push(self, new_data):             # Create a new Node        new_node = Node(new_data)         # Make next of new Node as head        new_node.next = self.head         # Move the head to point to new Node        self.head = new_node             # Method to print the linked list    def printList(self):         # Object to iterate        # the list        ptr = self.head         # Loop to iterate list        while(ptr != None):                         print(ptr.data, '-> ', end = '')             # Moving the iterating object            # to next node            ptr = ptr.next                     print()     # Method to delete a node in    # a singly linked list.    def deleteNode(self, key):        temp = self.head         # If head node itself holds        # the key to be deleted.        if(temp != None and temp.data == key):             # Changing head of list.            self.head = temp.next            return         # Search for the key to be        # deleted, keep track of the        # previous node as we need        # to change prev.next        while(temp != None and temp.data != key):            prev = temp            temp = temp.next         # If is not present in list        if(temp == None):            return         # Unlink the node from        # linked list        prev.next = temp.next     # Method to delete all the    # even nodes from singly    # linked list.    def deleteEvenNodes(self):        ptr = self.head         # Loop to iterate the        # linked list.        while(ptr != None):             # If node contains even number.            if(ptr.data % 2 == 0):                 # Deleting the node                self.deleteNode(ptr.data)                             ptr = ptr.next # Driver codeif __name__=='__main__':     head = LinkedList()         # Pushing elements at start    # of linked list.    head.push(19)    head.push(18)    head.push(3)    head.push(4)    head.push(1)         # Print initial linked list    print("Initial list: ", end = '')    head.printList()     # Calling the function to delete    # nodes containing even numbers.    head.deleteEvenNodes()     # Print the final list    print("Final list: ", end = '')    head.printList()     # This code is contributed by Amit Mangal
// C# implementation to delete all// even nodes from the singly linked listusing System;class List{   // 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;    }  }   // Function to insert a node at  // the beginning of the singly  // Linked List  public void push(int new_data)  {    Node new_node = new Node(new_data);    new_node.next = head;    head = new_node;  }   // Function to delete a node in a  // singly Linked List.  void deleteNode(int key)  {        // Store head node    Node temp = head, prev = null;     // If head node itself holds the    // key to be deleted    if (temp != null &&        temp.data == key)    {              // Changed head      head = temp.next;      return;    }     // Search for the key to be deleted,    // keep track of the previous node    // as we need to change temp.next    while (temp != null &&           temp.data != key)    {      prev = temp;      temp = temp.next;    }     // If key was not present    // in linked list    if (temp == null)      return;     // Unlink the node from    // linked list    prev.next = temp.next;  }   // Function to delete  // all the nodes  from  // linked list containing  // even numbers.  void deleteEvenNodes()  {    Node ptr = head;     // loop to iterate the linked list    while(ptr != null)    {      // If containing element is even      if(ptr.data % 2 == 0)      {                    // Delete the node        deleteNode(ptr.data);      }      ptr = ptr.next;    }  }   // This function prints contents of linked  // list starting from the given node  public void printList()  {    Node ptr = head;    while (ptr != null)    {      Console.Write(ptr.data + "-> ");      ptr = ptr.next;    }  }   // Driver code  public static void Main(String []args)  {    List head = new List();     head.push(19);    head.push(18);    head.push(3);    head.push(4);    head.push(1);     Console.Write("\nInitial List: ");    head.printList();     head.deleteEvenNodes();     Console.Write("\nFinal List: ");    head.printList();  }}  // This code contributed by gauravrajput1
<script>// javascript implementation to delete all// even nodes from the singly linked list     // head of list    var head;     // Linked list Node     class Node {            constructor(val) {                this.data = val;                this.next = null;            }        }     // Function to insert a node at    // the beginning of the singly    // Linked List     function push(new_data) {var new_node = new Node(new_data);        new_node.next = head;        head = new_node;    }     // Function to delete a node in a    // singly Linked List.    function deleteNode(key) {         // Store head nodevar temp = head, prev = null;         // If head node itself holds the        // key to be deleted        if (temp != null && temp.data == key) {             // Changed head            head = temp.next;            return;        }         // Search for the key to be deleted,        // keep track of the previous node        // as we need to change temp.next        while (temp != null && temp.data != key) {            prev = temp;            temp = temp.next;        }         // If key was not present in linked list        if (temp == null)            return;         // Unlink the node from linked list        prev.next = temp.next;    }     // Function to delete all the nodes    // from linked list containing    // even numbers.    function deleteEvenNodes() {var ptr = head;         // loop to iterate the linked list        while (ptr != null) {             // If containing element is even            if (ptr.data % 2 == 0) {                 // Delete the node                deleteNode(ptr.data);            }            ptr = ptr.next;        }    }     // This function prints contents of linked    // list starting from the given node     function printList() {var ptr = head;        while (ptr != null) {            document.write(ptr.data + "-> ");            ptr = ptr.next;        }    }     // Driver code              push(19);        push(18);        push(3);        push(4);        push(1);         document.write("<br/>Initial List: ");        printList();         deleteEvenNodes();         document.write("<br/>Final List: ");        printList(); // This code contributed by aashish1995</script>
Initial List:  1 ->  4 ->  3 ->  18 ->  19 -> 
Final List:  1 ->  3 ->  19 -> 
Time Complexity: O(N^2)
As the complexity of deleteNode function is O(N) and we need to call it for every even number.  
Auxiliary Space: O(1)
As constant extra space is used.
Approach 2:
The idea is to traverse the linked list one by one and get the pointer of nodes having even values. Also keep deleting the nodes having even values using the method used in this post.
We want the time complexity to be O(1) for deleting a given node in order to get O(N) solution for overall approach.
The algorithm for the deleteNode function:
In the deleteNode function we get the pointer  of the node to be deleted directly.Copy the value of next node’s to this node.delete the next node.
In the deleteNode function we get the pointer  of the node to be deleted directly.
Copy the value of next node’s to this node.
delete the next node.
The only thing to keep in mind is that the node to be deleted should not be the last node if we are using the above method to delete the node, but it gives the result in O(1) time so we will use this in our solution.
The algorithm for the deleteEvenNodes function:
We get the head of the linked list as a function parameter.Use dummy pointer variables ptr and prev which are used to store the current and previous node respectively.Traverse the linked list before last element using a while loop and do the following:    delete the nodes with odd values and keep updating the prev and ptr pointersThe case of last node is handled explicitly at the end.
We get the head of the linked list as a function parameter.
Use dummy pointer variables ptr and prev which are used to store the current and previous node respectively.
Traverse the linked list before last element using a while loop and do the following:
    delete the nodes with odd values and keep updating the prev and ptr pointers
The case of last node is handled explicitly at the end.
Full implementation of above approach:
C++
Java
Python3
C#
Javascript
// C++ implementation to delete all// even valed nodes from the singly linked list #include <bits/stdc++.h>using namespace std; // Node of the singly linked liststruct Node {    int data;    struct Node* next;}; // Function to insert a node at// the beginning of the singly// Linked Listvoid push(struct Node** head_ref, int new_data){    struct Node* new_node        = (struct Node*)malloc(sizeof(struct Node));     new_node->data = new_data;    new_node->next = (*head_ref);    (*head_ref) = new_node;} // Function to delete a node in a// singly Linked List.// node --> Pointer to given nodevoid deleteNode(struct Node* node){    // copy the next node's value in current node    node->data = node->next->data;    // store the pointer to node's next in a temp variable    struct Node* temp = node->next;    // connect the node with node's next's next    node->next = node->next->next;    // delete the temp    delete (temp);} // Function to delete all the// even valued nodes from the// singly linked listvoid deleteEvenNodes(Node** head_ref){    Node* ptr = *head_ref;    Node* prev;    // mark the current head with ptr pointer     while (ptr != NULL && ptr->next != NULL) {        // traverse the linked list before the last element        if (ptr->data % 2 == 0)            deleteNode(ptr);        // delete the node if the value of the node is even        else {            prev = ptr;            ptr = ptr->next;        }        // move the pointer to the next element and store        // the prev node    }    if (ptr == *head_ref && ptr->data % 2 == 0)        *head_ref = NULL;    else if (ptr->data % 2 == 0) {        prev->next = NULL;        delete ptr;    }} // This function prints contents// of linked list starting from// the given nodevoid printList(struct Node* node){    while (node != NULL) {        printf(" %d -> ", node->data);        node = node->next;    }} // Driver codeint main(){    // Start with the empty list    Node* head = NULL;    push(&head, 2);    push(&head, 6);    push(&head, 15);    push(&head, 16);    push(&head, 18);     printf("Initial List: ");    printList(head);     deleteEvenNodes(&head);     printf("\nFinal List: ");    printList(head);} // This code was contributed by Abhijeet Kumar
// Java implementation to delete all// even valued nodes from the singly linked listclass LinkedList{     // head of listNode head; // Linked list Nodeclass Node{    int data;    Node next;    Node(int d)    {        data = d;        next = null;    }} // Function to insert a node at// the beginning of the singly// Linked Listpublic void push(int new_data){    Node new_node = new Node(new_data);    new_node.next = head;    head = new_node;} // Function to delete a node in a// singly Linked List.void deleteNode(Node node){    // copy the next node's value in current node    node.data = node.next.data;         // connect the node with node's next's next    node.next = node.next.next;} // Function to delete all the nodes// from linked list containing// even numbers.void deleteEvenNodes(){    Node ptr = head;    Node prev = null;    //mark the current head with ptr pointer     while (ptr!=null && ptr.next != null)    {        // traverse the linked list before the last element        if (ptr.data % 2 == 0)            deleteNode(ptr);        // delete the node if the value of the node is even        else{        prev = ptr;        ptr = ptr.next;        }        // move the pointer to the next element and store the previous pointer    }    if(ptr==head && ptr.data % 2 == 0)      head = null;    else if(ptr.data % 2 == 0)    prev.next = null;} // This function prints contents of linked// list starting from the given nodepublic void printList(){    Node ptr = head;    while (ptr != null)    {        System.out.print(ptr.data + "-> ");        ptr = ptr.next;    }} // Driver codepublic static void main(String[] args){    LinkedList head = new LinkedList();     head.push(2);    head.push(6);    head.push(15);    head.push(16);    head.push(18);     System.out.print("\nInitial List: ");    head.printList();     head.deleteEvenNodes();     System.out.print("\nFinal List: ");    head.printList();}} // This code is contributed by Abhijeet Kumar(abhijeet19403)
# Python3 implementation to delete all# even valued nodes from the singly linked list # Node classclass Node:         # Function to initialize the node object    def __init__(self, data):                 # Assign data        self.data = data                 # Initialize        # next as null        self.next = None     # Linked List Classclass LinkedList:         # Function to initialize the    # LinkedList class.    def __init__(self):         # Initialize head as None        self.head = None     # This function insert a new node at    # the beginning of the linked list    def push(self, new_data):             # Create a new Node        new_node = Node(new_data)         # Make next of new Node as head        new_node.next = self.head         # Move the head to point to new Node        self.head = new_node             # Method to print the linked list    def printList(self):         # Object to iterate        # the list        ptr = self.head         # Loop to iterate list        while(ptr != None):                         print(ptr.data, '-> ', end = '')             # Moving the iterating object            # to next node            ptr = ptr.next                     print()     # Method to delete a node in    # a singly linked list.    def deleteNode(self,node):        # copy the next node's value in current node        node.data = node.next.data             # connect the node with node's next's next        node.next = node.next.next     # Method to delete all the    # even valued nodes from singly    # linked list.    def deleteEvenNodes(self):          #mark the current head with ptr pointer        ptr = self.head        prev = self.head                 # traverse the linked list before the last element        while (ptr!=None and ptr.next != None):            # delete the node if the value of the node is even            if (ptr.data % 2 == 0):                self.deleteNode(ptr)            # move the pointer to the next element and store the previous pointer            else:                prev = ptr                ptr = ptr.next                    if(ptr==self.head and ptr.data % 2 == 0):            head = None        elif(ptr.data % 2 == 0):            prev.next = None # Driver codeif __name__=='__main__':     head = LinkedList()         # Pushing elements at start    # of linked list.    head.push(18)    head.push(16)    head.push(15)    head.push(6)    head.push(2)         # Print initial linked list    print("Initial list: ", end = '')    head.printList()     # Calling the function to delete    # nodes containing even numbers.    head.deleteEvenNodes()     # Print the final list    print("Final list: ", end = '')    head.printList()     # This code is contributed by Abhijeet Kumar(abhijeet19403)
// C# implementation to delete all// even valued nodes from the singly linked listusing System;class List{   // 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;    }  }   // Function to insert a node at  // the beginning of the singly  // Linked List  public void push(int new_data)  {    Node new_node = new Node(new_data);    new_node.next = head;    head = new_node;  }   // Function to delete a node in a  // singly Linked List.  void deleteNode(Node node)  {       // copy the next node's value in current node    node.data = node.next.data;         // connect the node with node's next's next    node.next = node.next.next;  }   // Function to delete  // all the nodes  from  // linked list containing  // even numbers.  void deleteEvenNodes()  {     Node ptr = head;     Node prev = null;     //mark the current head with ptr pointer      while (ptr!=null && ptr.next != null)     {        // traverse the linked list before the last element        if (ptr.data % 2 == 0)            deleteNode(ptr);        // delete the node if the value of the node is even        else{        prev = ptr;        ptr = ptr.next;        }        // move the pointer to the next element and store the previous pointer     }     if(ptr==head && ptr.data % 2 == 0)       head = null;     else if(ptr.data % 2 == 0)     prev.next = null;  }   // This function prints contents of linked  // list starting from the given node  public void printList()  {    Node ptr = head;    while (ptr != null)    {      Console.Write(ptr.data + "-> ");      ptr = ptr.next;    }  }   // Driver code  public static void Main(String []args)  {    List head = new List();     head.push(2);    head.push(6);    head.push(15);    head.push(16);    head.push(18);     Console.Write("\nInitial List: ");    head.printList();     head.deleteEvenNodes();     Console.Write("\nFinal List: ");    head.printList();  }}  // This code contributed by Abhijeet Kumar(abhijeet19403)
<script>// javascript implementation to delete all// even nodes from the singly linked list     // head of list    var head;     // Linked list Node     class Node {            constructor(val) {                this.data = val;                this.next = null;            }        }             // Function to insert a node at    // the beginning of the singly    // Linked List     function push(new_data) {var new_node = new Node(new_data);        new_node.next = head;        head = new_node;    }     // Function to delete a node in a    // singly Linked List.    void deleteNode(Node node)    {        // copy the next node's value in current node        node.data = node.next.data;                 // connect the node with node's next's next        node.next = node.next.next;    }     // Function to delete all the nodes    // from linked list containing    // even numbers.    function deleteEvenNodes() {    var ptr = head,prev = null;    //mark the current head with ptr pointer     while (ptr!=null && ptr.next != null)    {        // traverse the linked list before the last element        if (ptr.data % 2 == 0)            deleteNode(ptr);        // delete the node if the value of the node is even        else{        prev = ptr;        ptr = ptr.next;        }        // move the pointer to the next element and store the previous pointer    }    if(ptr==head && ptr.data % 2 == 0)      head = null;    else if(ptr.data % 2 == 0)    prev.next = null;    }     // This function prints contents of linked    // list starting from the given node     function printList() {    var ptr = head;        while (ptr != null) {            document.write(ptr.data + "-> ");            ptr = ptr.next;        }    }     // Driver code              push(2);        push(6);        push(15);        push(16);        push(18);         document.write("<br/>Initial List: ");        printList();         deleteEvenNodes();         document.write("<br/>Final List: ");        printList(); // This code contributed by Abhijeet Kumar(abhijeet19403)</script>
Initial List:  18 ->  16 ->  15 ->  6 ->  2 -> 
Final List:  15 -> 
Time Complexity: O(N)
As we are visiting every node and deleting odd valued node which is O(1) operation.
Auxiliary Space: O(1)
As constant extra space is used.
This approach was contributed by Abhijeet Kumar. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
amit_mangal_
GauravRajput1
aashish1995
shubhamrajput6156
abhijeet19403
Data Structures
Linked List
School Programming
Write From Home
Data Structures
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Amazon Interview Experience for SDE-II
Binary Search Tree | Set 3 (Iterative Delete)
Data Structures | Linked List | Question 4
Data Structures | Balanced Binary Search Trees | Question 5
Improving Linear Search Technique
Linked List | Set 1 (Introduction)
Linked List | Set 2 (Inserting a node)
Reverse a linked list
Stack Data Structure (Introduction and Program)
Doubly Linked List | Set 1 (Introduction and Insertion)