Javascript Program To 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.

Javascript

<script>
// Javascript program to delete alternate
// nodes of a linked list

// Head of list
var head;

// 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 code
/* 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 is 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) because it is using constant space

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.

Javascript

<script>
/* Deletes alternate nodes of a list
   starting with head */
function deleteAlt(head)
{
    if (head == null)
        return;

    var node = head.next;

    if (node == null)
        return;

    // Change the next link of head
    /* Recursively call for the new
       next of head */
    head.next = node.next;
    head.next = deleteAlt(head.next);
}
// This code contributed by aashish1995
</script>

Time Complexity: O(n)

Auxiliary Space: O(n) for call stack

Please refer complete article on Delete alternate nodes of a Linked List for more details!