二叉树删除

Question

Given: The 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 tries 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.

[a link] http://www.geeksforgeeks.org/write-ac-program-to-delete-a-tree/

Doubt: In the deleteTree function the copy of the node from the main is passed then how are the actual memory of all these nodes freed in the deleteTree(). It is said the tree is deleted but for the tree to be deleted shouldn't we pass the address. Also if we consider that the tree is actually deleted then along with it the root node is also deleted so why doesn't it change to NULL in the main?

void deleteTree(struct node* node) 
{
  if (node == NULL) return;
  deleteTree(node->left);
  deleteTree(node->right);
  printf("\n Deleting node: %d", node->data);
  free(node);
}
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 ");

  getchar();
  return 0;
}

The modified code:

void _deleteTree(struct node* node)
{
  if (node == NULL) return;

  _deleteTree(node->left);
  _deleteTree(node->right);
  printf("\n Deleting node: %d", node->data);
  free(node);
}


void deleteTree(struct node** node_ref)
{
  _deleteTree(*node_ref);
  *node_ref = NULL;
}

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);
  printf("\n Tree deleted ");

  getchar();
  return 0;
}

How does the freeing happen in this case what if we set the root=NULL in main and not in the deleteTree function?

Answer 1

You are confusing two concepts - memory freeing, and setting the pointer to NULL . By using free the memory is freed and th pointer now points to an unallocated piece of memory. By setting the node* to NULL, you are indicating that the pointer is not valid - you can see that the code checks for that - if (node == NULL ) return; . If you just set the root to NULL you are creating a memory leak, since the memory pointed to remains allocated.

Also - It is said the tree is deleted but for the tree to be deleted shouldn't we pass the address - you are passing the address - deleteTree(&root); - root is a node* containing the address of the root node.

Hope this helps.

Answer 2

In the first code, function void deleteTree(struct node* node) calls itself(recursion) to free the memory of each node. It is said the tree is deleted but for the tree to be deleted shouldn't we pass the address , in fact the para node is a address of one node, it is a pointer( struct node * ). When you call free(node) , you free the memory which the node points to, not the node itself.

As for set root to NULL , the second code is same with your first code logically. If the function void deleteTree(struct node** node_ref) is inline, then after compiling, it will be same with your first code.