Delete alternate nodes of a Linked List

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++ 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 of 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

// 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 of 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

// Java program to delete alternate nodes of a linked list
class 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

# 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 of 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#

// C# program to delete alternate
// nodes of a linked list
using 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

Javascript

<script>

// Javascript program to delete alternate
// nodes of a linked list
var 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>

Output

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++

#include <iostream>

using namespace std;

// Define a structure for the linked list node
struct Node {
    int data;
    Node* next;
    
    Node(int value) : data(value), next(nullptr) {}
};

// Function to delete alternate nodes using recursion
void deleteAlt(Node* node) {
    if (node == nullptr || node->next == nullptr) {
        return;
    }
    
    Node* temp = node->next;
    node->next = temp->next;
    delete temp;
    
    deleteAlt(node->next);
}

// Function to print the linked list
void printList(Node* head) {
    while (head != nullptr) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}

int main() {
    // Create the linked list with the given input: 1, 2, 3, 4, 5
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);
    
    cout << "Original linked list: ";
    printList(head);
    
    // Call the function to delete alternate nodes
    deleteAlt(head);
    
    cout << "Modified linked list after deleting alternate nodes: ";
    printList(head);
    
    // Free memory
    Node* current = head;
    while (current != nullptr) {
        Node* next = current->next;
        delete current;
        current = next;
    }

    return 0;
}

C

#include <stdio.h>
#include <stdlib.h>

// Define a structure for the linked list node
struct Node {
    int data;
    struct Node* next;
};

// Function to delete alternate nodes using recursion
void deleteAlt(struct Node* node) {
    if (node == NULL || node->next == NULL) {
        return;
    }
    
    struct Node* temp = node->next;
    node->next = temp->next;
    free(temp);
    
    deleteAlt(node->next);
}

// Function to print the linked list
void printList(struct Node* head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

int main() {
    // Create the linked list with the given input: 1, 2, 3, 4, 5
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    head->data = 1;
    head->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->data = 2;
    head->next->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->next->data = 3;
    head->next->next->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->next->next->data = 4;
    head->next->next->next->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->next->next->next->data = 5;
    head->next->next->next->next->next = NULL;
    
    printf("Original linked list: ");
    printList(head);
    
    // Call the function to delete alternate nodes
    deleteAlt(head);
    
    printf("Modified linked list after deleting alternate nodes: ");
    printList(head);
    
    // Free memory
    struct Node* current = head;
    while (current != NULL) {
        struct Node* next = current->next;
        free(current);
        current = next;
    }

    return 0;
}

Java

class LinkedList {
    static class Node {
        int data;
        Node next;

        Node(int value) {
            data = value;
            next = null;
        }
    }

    // Function to delete alternate nodes using recursion
    static void deleteAlt(Node node) {
        if (node == null || node.next == null) {
            return;
        }

        Node temp = node.next;
        node.next = temp.next;
        temp = null;

        deleteAlt(node.next);
    }

    // Function to print the linked list
    static void printList(Node head) {
        while (head != null) {
            System.out.print(head.data + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Create the linked list with the given input: 1, 2, 3, 4, 5
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);

        System.out.print("Original linked list: ");
        printList(head);

        // Call the function to delete alternate nodes
        deleteAlt(head);

        System.out.print("Modified linked list after deleting alternate nodes: ");
        printList(head);
    }
}

Python3

class Node:
    def __init__(self, value):
        self.data = value
        self.next = None

# Function to delete alternate nodes using recursion
def delete_Alt(node):
    if node is None or node.next is None:
        return
    
    temp = node.next
    node.next = temp.next
    temp = None
    
    delete_Alt(node.next)

# Function to print the linked list
def print_list(head):
    while head:
        print(head.data, end=" ")
        head = head.next
    print()

# Create the linked list with the given input: 1, 2, 3, 4, 5
head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)
head.next.next.next.next = Node(5)

print("Original linked list:", end=" ")
print_list(head)

# Call the function to delete alternate nodes
delete_Alt(head)

print("Modified linked list after deleting alternate nodes:", end=" ")
print_list(head)

C#

using System;

class LinkedList {
    class Node {
        public int Data;
        public Node Next;

        public Node(int value) {
            Data = value;
            Next = null;
        }
    }

    // Function to delete alternate nodes using recursion
    static void DeleteAlt(Node node) {
        if (node == null || node.Next == null) {
            return;
        }

        Node temp = node.Next;
        node.Next = temp.Next;
        temp = null;

        DeleteAlt(node.Next);
    }

    // Function to print the linked list
    static void PrintList(Node head) {
        while (head != null) {
            Console.Write(head.Data + " ");
            head = head.Next;
        }
        Console.WriteLine();
    }

    static void Main(string[] args) {
        // Create the linked list with the given input: 1, 2, 3, 4, 5
        Node head = new Node(1);
        head.Next = new Node(2);
        head.Next.Next = new Node(3);
        head.Next.Next.Next = new Node(4);
        head.Next.Next.Next.Next = new Node(5);

        Console.Write("Original linked list: ");
        PrintList(head);

        // Call the function to delete alternate nodes
        DeleteAlt(head);

        Console.Write("Modified linked list after deleting alternate nodes: ");
        PrintList(head);
    }
}

Javascript

class Node {
    constructor(value) {
        this.data = value;
        this.next = null;
    }
}

// Function to delete alternate nodes using recursion
function deleteAlt(node) {
    if (node === null || node.next === null) {
        return;
    }

    let temp = node.next;
    node.next = temp.next;
    temp = null;

    deleteAlt(node.next);
}

// Function to print the linked list
function printList(head) {
    let current = head;
    while (current !== null) {
        process.stdout.write(current.data + " ");
        current = current.next;
    }
    console.log();
}

// Create the linked list with the given input: 1, 2, 3, 4, 5
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = new Node(4);
head.next.next.next.next = new Node(5);

process.stdout.write("Original linked list: ");
printList(head);

// Call the function to delete alternate nodes
deleteAlt(head);

process.stdout.write("Modified linked list after deleting: ");
printList(head);

Output

Original linked list: 1 2 3 4 5 
Modified linked list after deleting alternate nodes: 1 3 5 

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.

Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.