Write a program to Delete a Tree

To delete a tree we must traverse all the nodes of the tree and delete them one by one. So which traversal we should use – Inorder or Preorder or Postorder. Answer is simple – Postorder, because before deleting the parent node we should delete its children nodes first

We can delete tree with other traversals also with extra space complexity but why should we go for other traversals if we have Postorder available which does the work without storing anything in same time complexity.

For the following tree nodes are deleted in order – 4, 5, 2, 3, 1



Example Tree

Example Tree

Note : In Java automatic garbage collection happens, so we can simply make root null to delete the tree “root = null”;

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to Delete a Tree 
   
#include<bits/stdc++.h> 
#include<iostream>
using namespace std; 
  
/* A binary tree node has data,
pointer to left child and 
a pointer to right child */
class node 
    public:
    int data; 
    node* left; 
    node* right; 
      
    /* Constructor that allocates 
    a new node with the given data
    and NULL left and right pointers. */
    node(int data)
    {
        this->data = data; 
        this->left = NULL; 
        this->right = NULL; 
    }
}; 
  
  
/* This function traverses tree 
in post order to delete each 
and every node of the tree */
void deleteTree(node* node) 
    if (node == NULL) return
  
    /* first delete both subtrees */
    deleteTree(node->left); 
    deleteTree(node->right); 
      
    /* then delete the node */
    cout << "\n Deleting node: " << node->data; 
    free(node); 
  
  
/* Driver code*/
int main() 
    node *root = new node(1); 
    root->left     = new node(2); 
    root->right     = new node(3); 
    root->left->left = new node(4); 
    root->left->right = new node(5); 
      
    deleteTree(root); 
    root = NULL; 
  
    cout << "\n Tree deleted "
      
    return 0; 
  
//This code is contributed by rathbhupendra

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to Delete a Tree
#include<stdio.h>
#include<stdlib.h>
  
/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
struct node 
{
    int data;
    struct node* left;
    struct node* right;
};
  
/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data) 
{
    struct node* node = (struct node*)
                           malloc(sizeof(struct node));
  
    node->data = data;
    node->left = NULL;
    node->right = NULL;  
    return(node);
}
  
/*  This function traverses tree in post order to 
    to delete each and every node of the tree */
void deleteTree(struct node* node) 
{
    if (node == NULL) return;
  
    /* first delete both subtrees */
    deleteTree(node->left);
    deleteTree(node->right);
    
    /* then delete the node */
    printf("\n Deleting node: %d", node->data);
    free(node);
  
  
/* Driver program to test deleteTree function*/    
int main()
{
    struct node *root = newNode(1); 
    root->left            = newNode(2);
    root->right          = newNode(3);
    root->left->left     = newNode(4);
    root->left->right   = newNode(5); 
    
    deleteTree(root);  
    root = NULL;
  
    printf("\n Tree deleted ");
    
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to delete a tree
   
// A binary tree node
class Node 
{
    int data;
    Node left, right;
   
    Node(int item) 
    {
        data = item;
        left = right = null;
    }
}
   
class BinaryTree 
{
    Node root;
   
    /*  This function traverses tree in post order to 
        to delete each and every node of the tree */
    void deleteTree(Node node) 
    {
        // In Java automatic garbage collection
        // happens, so we can simply make root
        // null to delete the tree
        root = null;
    }
   
    /* Driver program to test above functions */
    public static void main(String[] args) 
    {
        BinaryTree tree = new BinaryTree();
   
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
   
        /* Print all root-to-leaf paths of the input tree */
        tree.deleteTree(tree.root);
        tree.root = null;
        System.out.println("Tree deleted");
   
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

""" program to Delete a Tree """
  
# Helper function that allocates a new 
# node with the given data and None 
# left and right poers.                                 
class newNode: 
  
    # Construct to create a new node 
    def __init__(self, key): 
        self.data = key
        self.left = None
        self.right = None
  
""" This function traverses tree in post order to 
    to delete each and every node of the tree """
def deleteTree( node) :
  
    if (node == None):
        return
  
    """ first delete both subtrees """
    deleteTree(node.left) 
    deleteTree(node.right) 
      
    """ then delete the node """
    print(" Deleting node:", node.data) 
  
  
# Driver Code 
if __name__ == '__main__':
    root = newNode(1
    root.left = newNode(2
    root.right = newNode(3
    root.left.left = newNode(4)
    root.left.right = newNode(5)
    deleteTree(root) 
    root = None
  
    print("Tree deleted ")
  
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

using System;
  
// C# program to delete a tree 
  
// A binary tree node 
public class Node
{
    public int data;
    public Node left, right;
  
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
public class BinaryTree
{
    public Node root;
  
    /*  This function traverses tree in post order to  
        to delete each and every node of the tree */
    public virtual void deleteTree(Node node)
    {
        // In Java automatic garbage collection 
        // happens, so we can simply make root 
        // null to delete the tree 
        root = null;
    }
  
    /* Driver program to test above functions */
    public static void Main(string[] args)
    {
        BinaryTree tree = new BinaryTree();
  
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
  
        /* Print all root-to-leaf paths of the input tree */
        tree.deleteTree(tree.root);
        tree.root = null;
        Console.WriteLine("Tree deleted");
  
    }
}
  
  // This code is contributed by Shrikant13

chevron_right



Output:

 Deleting node: 4
 Deleting node: 5
 Deleting node: 2
 Deleting node: 3
 Deleting node: 1
 Tree deleted 

The above deleteTree() function deletes the tree, but doesn’t change root to NULL which may cause problems if the user of deleteTree() doesn’t change root to NULL and tires to access values using root pointer. We can modify the deleteTree() function to take reference to the root node so that this problem doesn’t occur. See the following code.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to Delete a Tree 
#include <bits/stdc++.h>
using namespace std;
  
/* A binary tree node has data, pointer to left child 
and a pointer to right child */
class node 
    public:
    int data; 
    node* left; 
    node* right; 
}; 
  
/* Helper function that allocates a new node with the 
given data and NULL left and right pointers. */
node* newNode(int data) 
    node* Node = new node();
  
    Node->data = data; 
    Node->left = NULL; 
    Node->right = NULL; 
    return(Node); 
  
/* This function is same as deleteTree() 
in the previous program */
void _deleteTree(node* node) 
    if (node == NULL) return
  
    /* first delete both subtrees */
    _deleteTree(node->left); 
    _deleteTree(node->right); 
  
    /* then delete the node */
    cout << "Deleting node: " << node->data << endl; 
    free(node); 
  
/* Deletes a tree and sets the root as NULL */
void deleteTree(node** node_ref) 
    _deleteTree(*node_ref); 
    *node_ref = NULL; 
  
/* Driver code*/
int main() 
    node *root = newNode(1); 
    root->left     = newNode(2); 
    root->right     = newNode(3); 
    root->left->left = newNode(4); 
    root->left->right = newNode(5); 
  
    // Note that we pass the address of root here 
    deleteTree(&root); 
    cout << "Tree deleted "
    return 0; 
  
// This code is contributed by rathbhupendra

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to Delete a Tree
#include<stdio.h>
#include<stdlib.h>
  
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
struct node
{
    int data;
    struct node* left;
    struct node* right;
};
  
/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data)
{
    struct node* node = (struct node*)
                           malloc(sizeof(struct node));
  
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return(node);
}
  
/*  This function is same as deleteTree() in the previous program */
void _deleteTree(struct node* node)
{
    if (node == NULL) return;
  
    /* first delete both subtrees */
    _deleteTree(node->left);
    _deleteTree(node->right);
  
    /* then delete the node */
    printf("\n Deleting node: %d", node->data);
    free(node);
}
  
/* Deletes a tree and sets the root as NULL */
void deleteTree(struct node** node_ref)
{
  _deleteTree(*node_ref);
  *node_ref = NULL;
}
  
/* Driver program to test deleteTree function*/
int main()
{
    struct node *root = newNode(1);
    root->left            = newNode(2);
    root->right          = newNode(3);
    root->left->left     = newNode(4);
    root->left->right   = newNode(5);
  
    // Note that we pass the address of root here
    deleteTree(&root);
    printf("\n Tree deleted ");
  
    getchar();
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to delete a tree
   
/* A binary tree node has data, pointer to left child
   and pointer to right child */
class Node 
{
    int data;
    Node left, right;
   
    Node(int d) 
    {
        data = d;
        left = right = null;
    }
}
   
class BinaryTree
{
   
    static Node root;
   
    /*  This function is same as deleteTree() in the previous program */
    void deleteTree(Node node)
    {
        // In Java automatic garbage collection
        // happens, so we can simply make root
        // null to delete the tree
        root = null;
    }
      
    /* Wrapper function that deletes the tree and 
       sets root node as null  */
    void deleteTreeRef(Node nodeRef)
    {
        deleteTree(nodeRef);
        nodeRef=null;
    }
   
    /* Driver program to test deleteTree function */
    public static void main(String[] args)
    {
   
        BinaryTree tree = new BinaryTree();
   
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
   
        /* Note that we pass root node here */
        tree.deleteTreeRef(root);
        System.out.println("Tree deleted");
   
    }
}
  
// This code has been contributed by Mayank Jaiswal(mayank_24)

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to count all nodes 
# having k leaves in subtree rooted with them
  
# A binary tree node has data, pointer to 
# left child and a pointer to right child 
# Helper function that allocates a new node  
# with the given data and None left and
# right pointers 
class newNode:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
  
''' This function is same as deleteTree() 
in the previous program '''
def _deleteTree(node):
    if (node == None):
        return
  
    # first delete both subtrees */
    _deleteTree(node.left)
    _deleteTree(node.right)
  
    # then delete the node */
    print("Deleting node: ",
                  node.data)
    node = None
      
# Deletes a tree and sets the root as NULL
def deleteTree(node_ref):
    _deleteTree(node_ref[0])
    node_ref[0] = None
  
# Driver code
root = [0]
root[0] = newNode(1
root[0].left = newNode(2
root[0].right = newNode(3
root[0].left.left = newNode(4
root[0].left.right = newNode(5
  
# Note that we pass the address 
# of root here 
deleteTree(root) 
print("Tree deleted "
  
# This code is contributed by SHUBHAMSINGH10

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

using System;
  
// C# program to delete a tree 
  
/* A binary tree node has data, pointer to left child 
   and pointer to right child */
public class Node
{
    public int data;
    public Node left, right;
  
    public Node(int d)
    {
        data = d;
        left = right = null;
    }
}
  
public class BinaryTree
{
  
    public static Node root;
  
    /*  This function is same as deleteTree() in the previous program */
    public virtual void deleteTree(Node node)
    {
        // In Java automatic garbage collection 
        // happens, so we can simply make root 
        // null to delete the tree 
        root = null;
    }
  
    /* Wrapper function that deletes the tree and  
       sets root node as null  */
    public virtual void deleteTreeRef(Node nodeRef)
    {
        deleteTree(nodeRef);
        nodeRef = null;
    }
  
    /* Driver program to test deleteTree function */
    public static void Main(string[] args)
    {
  
        BinaryTree tree = new BinaryTree();
  
        BinaryTree.root = new Node(1);
        BinaryTree.root.left = new Node(2);
        BinaryTree.root.right = new Node(3);
        BinaryTree.root.left.left = new Node(4);
        BinaryTree.root.left.right = new Node(5);
  
        /* Note that we pass root node here */
        tree.deleteTreeRef(root);
        Console.WriteLine("Tree deleted");
  
    }
}
  
  // This code is contributed by Shrikant13

chevron_right



Output:

 Deleting node: 4
 Deleting node: 5
 Deleting node: 2
 Deleting node: 3
 Deleting node: 1
 Tree deleted 

Time Complexity: O(n)
Space Complexity: If we don’t consider size of stack for function calls then O(1) otherwise O(n)



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


6


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.