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);
}

void delete_tree(TreeNode **n)
{
	if((*n) == NULL)
		return;

	if((*n)->left != NULL)
		delete_tree(&((*n)->left));
	
	if((*n)->right != NULL)
		delete_tree(&((*n)->right));

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

static void delete_tree(struct huffman_node *node)
{
	struct huffman_node *left, *right;

	if (node == NULL)
		return;
	left = node->next[0];
	right = node->next[1];

	kfree(node);

	delete_tree(left);	/* left child */
	delete_tree(right); /* right child */
}

Node* analyze_line(String* str)
{
	Node* node;

	st_token_buf = NULL;
	lexer_init(str);
	parser_init();

	node = parse_acceptable();
	switch ( parser_state() ) {
	case PS_ACCEPT:
		if ( node == NULL ) {
			fprintf(stderr, "parse error\n");
		}
		break;
	case PS_ERROR:
		parser_print_error();
		if ( node != NULL ) {
			delete_tree(node);
			node = NULL;
		}
		break;
	}
	
	if ( st_token_buf != NULL) {
		delete_token(st_token_buf);
		st_token_buf = NULL;
	}

	return node;
}

int main ()
{
	short flag = 11;							/// flag for menu
	leaf *root;									/// root of tree

	root = new leaf;
	root->parent = NULL;						/// totaly null root of tree
	root->son_l = NULL;							
	root->son_r = NULL;							
	root->val = NULL;							

	while(1)
	{
		switch (give_mFlag())					/// give flag
		{
		case 1: 
			create_tree(root);					/// create tree
			printf("\n....tree was created");
			break;
		case 2:
			print_tree(root);					/// print tree
			break;
		case 0:
			delete_tree(root);					/// destroy tree 
			printf("\n....tree was destroied"); 
			flag = EXIT_WHILE;					/// and exit from programm
			break;
		}
		if (flag == EXIT_WHILE) break;
	}

	getchar();
	getchar();
}

void rt_pvd_file::delete_tree(pwr_tOix oix)
{
  m_list[oix].flags |= procom_obj_mFlags_Deleted;

  for (pwr_tOix ix = m_list[oix].fchoix; ix; ix = m_list[ix].fwsoix)
    delete_tree(ix);
}