Delete alternate nodes of a Linked List

03 Jul, 2022
Given a Singly Linked List, starting from the second node delete all alternate nodes of it. For example, if the given linked list is 1->2->3->4->5 then your function should convert it to 1->3->5, and if the given linked list is 1->2->3->4 then convert it to 1->3. 
Method 1 (Iterative) Keep track of previous of the node to be deleted. First, change the next link of the previous node and iteratively move to the next node.   
C++
C
Java
Python3
C#
Javascript
// C++ program to remove alternate // nodes of a linked list #include <bits/stdc++.h>using namespace std;  /* A linked list node */class Node {     public:    int data;     Node *next; };   /* deletes alternate nodes of a list starting with head */void deleteAlt(Node *head) {     if (head == NULL)         return;       /* Initialize prev and node to be deleted */    Node *prev = head;     Node *node = head->next;       while (prev != NULL && node != NULL)     {         /* Change next link of previous node */        prev->next = node->next;         delete(node); // delete the node        /* Update prev and node */        prev = prev->next;         if (prev != NULL)             node = prev->next;     } }   /* UTILITY FUNCTIONS TO TEST fun1() and fun2() *//* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */void push(Node** head_ref, int new_data) {     /* allocate node */    Node* new_node = new Node();      /* put in the data */    new_node->data = new_data;       /* link the old list off the new node */    new_node->next = (*head_ref);       /* move the head to point to the new node */    (*head_ref) = new_node; }   /* Function to print nodes in a given linked list */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;       /* Using push() to construct below list     1->2->3->4->5 */    push(&head, 5);     push(&head, 4);     push(&head, 3);     push(&head, 2);     push(&head, 1);       cout<<"List before calling deleteAlt() \n";     printList(head);       deleteAlt(head);       cout<<"\nList after calling deleteAlt() \n";     printList(head);       return 0; }   // This code is contributed by rathbhupendra
// C program to remove alternate nodes of a linked list#include<stdio.h>#include<stdlib.h>  /* A linked list node */struct Node{    int data;    struct Node *next;};  /* deletes alternate nodes of a list starting with head */void deleteAlt(struct Node *head){    if (head == NULL)        return;      /* Initialize prev and node to be deleted */    struct Node *prev = head;    struct Node *node = head->next;      while (prev != NULL && node != NULL)    {        /* Change next link of previous node */        prev->next = node->next;          /* Free memory */        free(node);          /* Update prev and node */        prev = prev->next;        if (prev != NULL)            node = prev->next;    }}  /* UTILITY FUNCTIONS TO TEST fun1() and fun2() *//* Given a reference (pointer to pointer) to the head  of a list and an int, push a new node on the front  of the list. */void push(struct Node** head_ref, int new_data){    /* allocate node */    struct Node* new_node =        (struct Node*) malloc(sizeof(struct Node));      /* put in the data  */    new_node->data  = new_data;      /* link the old list off the new node */    new_node->next = (*head_ref);      /* move the head to point to the new node */    (*head_ref)    = new_node;}  /* Function to print nodes in a given linked list */void printList(struct Node *node){    while (node != NULL)    {        printf("%d ", node->data);        node = node->next;    }}  /* Driver program to test above functions */int main(){    /* Start with the empty list */    struct Node* head = NULL;      /* Using push() to construct below list      1->2->3->4->5  */    push(&head, 5);    push(&head, 4);    push(&head, 3);    push(&head, 2);    push(&head, 1);      printf("\nList before calling deleteAlt() \n");    printList(head);      deleteAlt(head);      printf("\nList after calling deleteAlt() \n");    printList(head);      return 0;}
// Java program to delete alternate nodes of a linked listclass LinkedList {    Node head; // head of list      /* Linked list Node*/    class Node {        int data;        Node next;        Node(int d)        {            data = d;            next = null;        }    }      void deleteAlt()    {        if (head == null)            return;          Node node = head;          while (node != null && node.next != null) {            /* Change next link of next node */            node.next = node.next.next;              /*Update ref node to new alternate node */            node = node.next;        }    }      /* Utility functions */      /* 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;    }      /* Function to print linked list */    void printList()    {        Node temp = head;        while (temp != null) {            System.out.print(temp.data + " ");            temp = temp.next;        }        System.out.println();    }      /* Driver program to test above functions */    public static void main(String args[])    {        LinkedList llist = new LinkedList();          /* Constructed Linked List is 1->2->3->4->5->null */        llist.push(5);        llist.push(4);        llist.push(3);        llist.push(2);        llist.push(1);          System.out.println(            "Linked List before calling deleteAlt() ");        llist.printList();          llist.deleteAlt();          System.out.println(            "Linked List after calling deleteAlt() ");        llist.printList();    }}/* This code is contributed by Rajat Mishra */
# Python3 program to remove alternate # nodes of a linked list import math   # A linked list node class Node:     def __init__(self, data):         self.data = data         self.next = None          # deletes alternate nodes # of a list starting with head def deleteAlt(head):     if (head == None):        return      # Initialize prev and node to be deleted     prev = head     now = head.next      while (prev != None and now != None):                   # Change next link of previous node         prev.next = now.next          # Free memory         now = None          # Update prev and node         prev = prev.next        if (prev != None):             now = prev.next      # UTILITY FUNCTIONS TO TEST fun1() and fun2() # Given a reference (pointer to pointer) to the head # of a list and an , push a new node on the front # of the list. def push(head_ref, new_data):           # allocate node     new_node = Node(new_data)      # put in the data     new_node.data = new_data       # link the old list off the new node     new_node.next = head_ref       # move the head to point to the new node     head_ref = new_node     return head_ref  # Function to print nodes in a given linked list def printList(node):     while (node != None):         print(node.data, end = " ")         node = node.next      # Driver code if __name__=='__main__':           # Start with the empty list     head = None      # Using head=push() to construct below list     # 1.2.3.4.5     head = push(head, 5)     head = push(head, 4)     head = push(head, 3)     head = push(head, 2)     head = push(head, 1)       print("List before calling deleteAlt() ")    printList(head)       deleteAlt(head)       print("\nList after calling deleteAlt() ")     printList(head)   # This code is contributed by Srathore
// C# program to delete alternate// nodes of a linked listusing System;  public class LinkedList{    Node head; // head of list      /* Linked list Node*/    public class Node    {        public int data;        public Node next;        public Node(int d)         {            data = d; next = null;                       }    }      void deleteAlt()    {        if (head == null)             return;          Node prev = head;        Node now = head.next;          while (prev != null && now != null)         {                     /* Change next link of previous node */            prev.next = now.next;              /* Free node */            now = null;              /*Update prev and now */            prev = prev.next;            if (prev != null)                 now = prev.next;        }    }                                             /* Utility functions */      /* 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;    }      /* Function to print linked list */    void printList()    {        Node temp = head;        while(temp != null)        {        Console.Write(temp.data+" ");        temp = temp.next;        }         Console.WriteLine();    }      /* Driver code*/    public static void Main(String []args)    {        LinkedList llist = new LinkedList();                  /* Constructed Linked List is        1->2->3->4->5->null */        llist.push(5);        llist.push(4);        llist.push(3);        llist.push(2);        llist.push(1);                  Console.WriteLine("Linked List before" +                             "calling deleteAlt() ");        llist.printList();                  llist.deleteAlt();                  Console.WriteLine("Linked List after" +                             "calling deleteAlt() ");        llist.printList();    }}  // This code has been contributed // by 29AjayKumar
<script>  // Javascript program to delete alternate// nodes of a linked listvar head; // head of list      /* Linked list Node */     class Node {            constructor(val) {                this.data = val;                this.next = null;            }        }           function deleteAlt() {        if (head == null)            return;          var prev = head;        var now = head.next;          while (prev != null && now != null) {            /* Change next link of previous node */            prev.next = now.next;              /* Free node */            now = null;              /* Update prev and now */            prev = prev.next;            if (prev != null)                now = prev.next;        }    }      /* Utility functions */      /* 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;    }      /* Function to print linked list */    function printList() {        var temp = head;        while (temp != null) {            document.write(temp.data + " ");            temp = temp.next;        }        document.write("<br/>");    }      /* Driver program to test above functions */            /* Constructed Linked List is        1->2->3->4->5->null */        push(5);        push(4);        push(3);        push(2);        push(1);          document.write(        "Linked List before calling deleteAlt() <br/>"        );        printList();          deleteAlt();          document.write(        "Linked List after calling deleteAlt()<br/> "        );        printList();  // This code contributed by gauravrajput1   </script>
List before calling deleteAlt() 
1 2 3 4 5 
List after calling deleteAlt() 
1 3 5 
Time Complexity: O(n) 
where n is the number of nodes in the given Linked List.
Auxiliary Space: O(1)
As constant extra space is used.
Method 2 (Recursive) Recursive code uses the same approach as method 1. The recursive code is simple and short but causes O(n) recursive function calls for a linked list of size n.  
C++
C
Java
Python3
C#
Javascript
/* deletes alternate nodes of a list starting with head */void deleteAlt(Node *head) {     if (head == NULL)         return;       Node *node = head->next;       if (node == NULL)         return;       /* Change the next link of head */    head->next = node->next;       /* free memory allocated for node */    free(node);       /* Recursively call for the new next of head */    deleteAlt(head->next); }   // This code is contributed by rathbhupendra
/* deletes alternate nodes of a list starting with head */void deleteAlt(struct Node *head){    if (head == NULL)        return;      struct Node *node = head->next;      if (node == NULL)        return;      /* Change the next link of head */    head->next = node->next;      /* free memory allocated for node */    free(node);      /* Recursively call for the new next of head */    deleteAlt(head->next);}
/* deletes alternate nodes of a liststarting with head */static Node deleteAlt(Node head) {     if (head == null)         return;       Node node = head.next;       if (node == null)         return;       /* Change the next link of head */    head.next = node.next;         /* Recursively call for the new next of head */    head.next = deleteAlt(head.next); }   // This code is contributed by Arnab Kundu
# deletes alternate nodes of a list starting with head def deleteAlt(head):     if (head == None):         return      node = head.next      if (node == None):         return      # Change the next link of head     head.next = node.next      # free memory allocated for node     #free(node)       # Recursively call for the new next of head     deleteAlt(head.next)   # This code is contributed by Srathore
/* deletes alternate nodes of a liststarting with head */static Node deleteAlt(Node head) {     if (head == null)         return;       Node node = head.next;       if (node == null)         return;       /* Change the next link of head */    head.next = node.next;         /* Recursively call for the new next of head */    head.next = deleteAlt(head.next); }   // This code is contributed by Arnab Kundu
<script>/* deletes alternate nodes of a liststarting with head */function deleteAlt(head) {     if (head == null)         return;       var node = head.next;       if (node == null)         return;       /* Change the next link of head */    head.next = node.next;    /* Recursively call for the new next of head */    head.next = deleteAlt(head.next); }     // This code contributed by aashish1995 </script>
Time Complexity: O(n)
Auxiliary Space: O(1)
As this is a tail recursive function no function call stack is required thus the extra space used is constant. 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem. 
29AjayKumar
rathbhupendra
andrew1234
sapnasingh4991
Akanksha_Rai
nidhi_biet
arorakashish0911
GauravRajput1
aashish1995
simmytarika5
surindertarika1234
surinderdawra388
ashwinaditya21
abhijeet19403
Morgan Stanley
Python-Data-Structures
Linked List
Morgan Stanley
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Implementing a Linked List in Java using Class
Find Length of a Linked List (Iterative and Recursive)
Remove duplicates from an unsorted linked list
Write a function to get the intersection point of two Linked Lists
Queue - Linked List Implementation
Function to check if a singly linked list is palindrome
Circular Linked List | Set 1 (Introduction and Applications)
Implement a stack using singly linked list