Delete a linked list using recursion

Delete the given linked list using recursion

Method:

1. If head equal to NULL then linked list is empty, we simply return. 
2. Recursively delete linked list after head node. 
3. Delete head node. 

Implementation:

C++

// C++ program to recursively delete a linked list
#include <bits/stdc++.h>

/* Link list node */
struct Node {
    int data;
    struct Node* next;
};

/* Recursive Function to delete the entire linked list */
void deleteList(struct Node* head)
{
    if (head == NULL)
        return;
    deleteList(head->next);
    free(head);
}

/* 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)
{
    struct Node* new_node = new Node;
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}

/* Driver program to test count function*/
int main()
{
    /* Start with the empty list */
    struct Node* head = NULL;

    /* Use push() to construct below list
    1->12->1->4->1 */
    push(&head, 1);
    push(&head, 4);
    push(&head, 1);
    push(&head, 12);
    push(&head, 1);
    printf("\n Deleting linked list");
    deleteList(head);

      // Since head now points to illgal address, we should set head = NULL:
      head = NULL;
    printf("\nLinked list deleted");
    return 0;
}

Java

// Java program to recursively delete a linked list
class GFG
{

/* Link list node */
static class Node
{
    int data;
    Node next;
};

/* Recursive Function to delete
the entire linked list */
static void deleteList(Node head)
{
    if (head == null)
        return;
    deleteList(head.next);
    System.gc();
}

/* 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. */
static void push(Node head_ref, int new_data)
{
    Node new_node = new Node();
    new_node.data = new_data;
    new_node.next = head_ref;
    head_ref = new_node;
}

/* Driver code*/
public static void main(String[] args)
{
    /* Start with the empty list */
    Node head = new Node();

    /* Use push() to construct below list
    1->12->1->4->1 */
    push(head, 1);
    push(head, 4);
    push(head, 1);
    push(head, 12);
    push(head, 1);
    System.out.print("\nDeleting linked list");
    deleteList(head);
    System.out.print("\nLinked list deleted");
}
}

/* This code contributed by PrinciRaj1992 */

Python3

# Python3 program to recursively delete
# a linked list
import math

# Link list node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# Recursive Function to delete
# the entire linked list
def deleteList(head):
    if (head == None):
        return
    deleteList(head.next)
    # free(head)

# Given a reference (pointer to pointer) to the head
# of a list and an int, head=push a new node
# on the front of the list.
def push(head_ref, new_data):
    new_node = Node(new_data)
    new_node.data = new_data
    new_node.next = head_ref
    head_ref = new_node
    return head_ref

# Driver Code
if __name__=='__main__':

    # Start with the empty list
    head = None

    # Use head=push() to construct below list 1.12.1.4.1
    head = push(head, 1)
    head = push(head, 4)
    head = push(head, 1)
    head = push(head, 12)
    head = push(head, 1)
    print("Deleting linked list")
    deleteList(head)
    print("Linked list deleted")

# This code is contributed by Srathore

C#

// C# program to recursively delete a linked list
using System;

class GFG
{

/* Link list node */
public class Node
{
    public int data;
    public Node next;
};

/* Recursive Function to delete
the entire linked list */
static void deleteList(Node head)
{
    if (head == null)
        return;
    deleteList(head.next);
}

/* 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. */
static void push(Node head_ref, int new_data)
{
    Node new_node = new Node();
    new_node.data = new_data;
    new_node.next = head_ref;
    head_ref = new_node;
}

/* Driver code*/
public static void Main(String[] args)
{
    /* Start with the empty list */
    Node head = new Node();

    /* Use push() to construct below list
    1->12->1->4->1 */
    push(head, 1);
    push(head, 4);
    push(head, 1);
    push(head, 12);
    push(head, 1);
    Console.Write("\nDeleting linked list");
    deleteList(head);
    Console.Write("\nLinked list deleted");
}
}

// This code contributed by Rajput-Ji

Javascript

<script>

// JavaScript program to recursively delete a linked list

/* Link list node */
class Node
{
    constructor()
    {
        this.data = 0;
        this.next = null;
    }
};

/* Recursive Function to delete
the entire linked list */
function deleteList(head)
{
    if (head == null)
        return;
    deleteList(head.next);
}

/* 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. */
function push(head_ref, new_data)
{
    var new_node = new Node();
    new_node.data = new_data;
    new_node.next = head_ref;
    head_ref = new_node;
}

/* Driver code*/
/* Start with the empty list */
var head = new Node();
/* Use push() to construct below list
1->12->1->4->1 */
push(head, 1);
push(head, 4);
push(head, 1);
push(head, 12);
push(head, 1);
document.write("Deleting linked list");
deleteList(head);
document.write("<br>Linked list deleted");


</script>

Output

 Deleting linked list
Linked list deleted

Time Complexity: O(N), where N is the number of nodes in the given linked list.
Auxiliary Space: O(N) due to recursion call stack.