 GeeksforGeeks App
Open App Browser
Continue

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

Recommended Practice

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 ``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``#include`` ` `/* 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

 ``

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

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

## C

 `/* 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);``}`

## Java

 `/* deletes alternate nodes of a list``starting 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`

## Python3

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

## C#

 `/* deletes alternate nodes of a list``starting 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`

## Javascript

 ``

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.

My Personal Notes arrow_drop_up