C++ delete_tree函数代码示例

void delete_tree(tree root)
{
	if (NULL != root) {

		delete_tree(root->child);
		delete_tree(root->next);
		free(root);
	}
}

void delete_tree(Tree * t) 
{
    if (!t) return;

    if (t->left) delete_tree(t->left);
    if (t->right) delete_tree(t->right);

    delete t;
}

/**
 * Deletes the tree from node n and gives the memory back 
 * to free heap space.
 */
void delete_tree(node** n) {
	if(*n != NULL) {
		delete_tree(&((*n)->left));
		delete_tree(&((*n)->right));
		free((*n)->word);
		free(*n);
		*n = NULL;
	}
}

void delete_tree(tnode_t **tree) {
    if (*tree == NULL) return;

    delete_tree(&(*tree)->lchild);
    delete_tree(&(*tree)->rchild);

    free(*tree);
    *tree = NULL;
}

void delete_tree(tree_node* parent) {
	if(parent->right_child)
		delete_tree(parent->right_child);
	if(parent->left_child)
		delete_tree(parent->left_child);
	if(parent->points)
		free(parent->points);
	free(parent);
}

void FAGeneral::delete_tree(Group *g){
  Group *gfdown = g->fatherdown;
  if (gfdown!= NullGroup){
    gfdown->childup = 0;
  }
  Group *g1=g->childup,*g2=g->childdown;
  if(g1 != NullGroup)delete_tree(g1);
  if(g2 != NullGroup)delete_tree(g2);
  delete g;
}

	void delete_tree(Node *& treeRoot)
	{
		if (treeRoot == nullptr)
			return;
		delete_tree(treeRoot->left);
		delete_tree(treeRoot->right);
		treeRoot->parent = nullptr;
		delete treeRoot;
		treeRoot = nullptr;
	}

/**
 * 回收构造树的内存空间
 */
void delete_tree(pnode & root)
{
    if(root != NULL)
    {
        delete_tree(root->lchild);
        delete_tree(root->rchild);
        cout << "free the node " << root -> value << endl;
        delete root;
        root = NULL;
    }
}

/** @function delete_tree(leaf *root)
    @brief	Delete tree
    @param	*root
*/
void delete_tree(leaf *root)
{
	if(!root) return;

	delete_tree(root->son_l);
	delete_tree(root->son_r);
	if(root->val) 
	{
		printf("\n....destroy (%d)", root->val);
		delete root;
	}
}

void delete_tree(node * current)
{
    if(current==NULL)
    {
       return;
    }
    else
    {
        delete_tree(current->lchild);
        delete_tree(current->rchild);
        free(current);
    }
}

int delete_tree(tree_node* root)
{
  static int deleted_nodes = 0;

  if (root == NULL)
    return 0;

  delete_tree(root->left);
  delete_tree(root->right);
  free(root);

  return ++deleted_nodes;
}

static void delete_tree( rbt_tree *tree, node_type *p )
{
	tag_type *rbt = ( tag_type * )tree;

	// Erase nodes in depth-first traversal.
	if ( p == &rbt->sentinel )
	{
		return;
	}

	delete_tree( tree, p->left );
	delete_tree( tree, p->right );
	free( p );
}

void delete_tree(NODE *root)
{
	if(root->left!=NULL)
	{
		delete_tree(root->left);
	}

	if(root->right!=NULL)
	{
		delete_tree(root->right);
	}

	free(root);
}

void delete_tree(NODE *root)
{
	if(root->previous!=NULL)
	{
		delete_tree(root->previous);
	}

	if(root->next!=NULL)
	{
		delete_tree(root->next);
	}

	free(root);
}

void delete_tree(NODE *root)
{
	if(root->left_child!=NULL)
	{
		delete_tree(root->left_child);
	}

	if(root->right_child!=NULL)
	{
		delete_tree(root->right_child);
	}

	free(root);
}