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);
}
/* Deep copies the tree */
struct treap_node *copy_tree(struct treap_node *root, int *status) {
struct treap_node *copy, *left, *right;
if (!root)
return NULL;
copy = kmalloc(sizeof(struct treap_node), GFP_KERNEL);
if (!copy) {
*status = NO_MEMORY;
goto fail;
}
memcpy(copy, root, sizeof(struct treap_node));
copy->pointers[LEFT] = copy->pointers[RIGHT] = copy->pointers[PARENT] = NULL;
left = copy_tree(root->pointers[LEFT], status);
if (*status == NO_MEMORY)
goto fail;
right = copy_tree(root->pointers[LEFT], status);
if (*status == NO_MEMORY)
goto fail;
copy->pointers[LEFT] = left;
copy->pointers[RIGHT] = right;
left->pointers[PARENT] = copy;
right->pointers[PARENT] = copy;
return copy;
fail:
delete_tree(copy);
return NULL;
}
FT_WORD * ft_linearize(TREE *wtree, MEM_ROOT *mem_root)
{
FT_WORD *wlist,*p;
FT_DOCSTAT docstat;
DBUG_ENTER("ft_linearize");
if ((wlist=(FT_WORD *) alloc_root(mem_root, sizeof(FT_WORD)*
(1+wtree->elements_in_tree))))
{
docstat.list=wlist;
docstat.uniq=wtree->elements_in_tree;
docstat.sum=0;
tree_walk(wtree,(tree_walk_action)&walk_and_copy,&docstat,left_root_right);
}
delete_tree(wtree);
if (!wlist)
DBUG_RETURN(NULL);
docstat.list->pos=NULL;
for (p=wlist;p->pos;p++)
{
p->weight=PRENORM_IN_USE;
}
for (p=wlist;p->pos;p++)
{
p->weight/=NORM_IN_USE;
}
DBUG_RETURN(wlist);
}
void driver_for_convert_string_to_tree()
{
printf("INPUT THE A BST IN THE FOLLOWINT FORMAT:\n FOR A TREE WITH 1 AS ROOT AND 2&3 AS ITS LEFT AND RIGHT CHILDREN ENTER THE INPUT AS\n([1,1],[2,1],[3,1])\n");
char *string = (char*)malloc(1024*sizeof(char));
gets_s(string,1024);
int *position_of_delimiters = count_delimiters(string);
NODE *root = (NODE*)malloc(sizeof(NODE));
convert_string_to_tree(string,0,position_of_delimiters,root);
free(position_of_delimiters);
int node1_value, node2_value;
printf("ENTER THE NODE VALUES:\n");
scanf_s("%d",&node1_value);
scanf_s("%d",&node2_value);
NODE *node1 = find_node(root, node1_value);
NODE *node2 = find_node(root,node2_value);
if(node1==NULL || node2==NULL)
{
printf("INVALID INPUT");
getchar();
return;
}
printf("LEAST COMMON ANCESTOR IS %d\n",find_least_common_ancestor(node1,node2)->data);
delete_tree(root);
free(string);
}
void MAXIMUM_NODE_IN_TREE()
{
char input[5][52] = {
"1,$",
"2,4,1,$,-,3,$",
"1,2,$,-",
"1,3,$,2,$",
"14,1,4,2,$,6,$,10,8,$,12,$,13,3,15,$,5,$,9,7,$,11,$"
};
int expected_output[6] = {1,4,2,3,15};
int iter_loop, index;
for(iter_loop=0;iter_loop<5;iter_loop++)
{
NODE *root = (NODE*)malloc(sizeof(NODE));
index = next_element_in_string(input[iter_loop],0);
root->data = create_number(input[iter_loop],index);
index = next_element_in_string(input[iter_loop],index);
construct_tree(root,input[iter_loop],index);
int previous_value = root->data;
Inorder(root,&previous_value);
(expected_output[iter_loop]==previous_value)?printf("ACCEPTED\n"):printf("REJECTED\n");
delete_tree(root);
}
}
int ft_parse(TREE *wtree, byte *doc, int doclen, my_bool with_alloc)
{
byte *end=doc+doclen;
FT_WORD w;
DBUG_ENTER("ft_parse");
while (ft_simple_get_word(wtree->custom_arg, &doc, end, &w, TRUE))
{
if (with_alloc)
{
byte *ptr;
/* allocating the data in the tree - to avoid mallocs and frees */
DBUG_ASSERT(wtree->with_delete==0);
ptr=(byte *)alloc_root(& wtree->mem_root,w.len);
memcpy(ptr, w.pos, w.len);
w.pos=ptr;
}
if (!tree_insert(wtree, &w, 0, wtree->custom_arg))
goto err;
}
DBUG_RETURN(0);
err:
delete_tree(wtree);
DBUG_RETURN(1);
}
void hp_clear_keys(HP_SHARE *info)
{
uint key;
DBUG_ENTER("hp_clear_keys");
for (key=0 ; key < info->keys ; key++)
{
HP_KEYDEF *keyinfo = info->keydef + key;
if (keyinfo->algorithm == HA_KEY_ALG_BTREE)
{
delete_tree(&keyinfo->rb_tree);
}
else
{
HP_BLOCK *block= &keyinfo->block;
if (block->levels)
VOID(hp_free_level(block,block->levels,block->root,(byte*) 0));
block->levels=0;
block->last_allocated=0;
keyinfo->hash_buckets= 0;
}
}
info->index_length=0;
DBUG_VOID_RETURN;
}
int main()
{
char _[] = "deadbeef";
tree_t t = create_tree(_, strlen(_));
inorder_traversal(t, print_node);
sep;
printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)),
retrieve(find('a', t)));
sep;
t = insert_tree('z', t);
printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)),
retrieve(find('a', t)));
sep;
inorder_traversal(t, print_node);
sep;
delete_tree('z', t);
printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)),
retrieve(find('a', t)));
sep;
inorder_traversal(t, print_node);
dispose_tree(t);
return 0;
}
char *add_existing_tests()
{
tree *first = NULL;
int data[MAX_ELEMENT];
unsigned int result;
unsigned int element_in_tree = 0;
int i = 0;
unsigned long rand_seed = (unsigned long) time(NULL);
ILOG("Random seed: %lu", rand_seed);
srand(rand_seed);
for (i = 0; i < MAX_ELEMENT; i++) {
data[i] = rand();
}
// Try to allocate a new tree.
first = init_dictionnary(data_cmp, data_print, data_delete, NULL);
if (first == NULL) {
ELOG("Init dictionnary error");
return "Init dictionnary error";
}
verif_tree(first);
for (i = 0; i < MAX_ELEMENT; i++) {
if (!is_present(first, &(data[i]))) {
element_in_tree++;
}
result = insert_elmt(first, &(data[i]), sizeof(int));
if (result != element_in_tree) {
ELOG("Wrong result of inserted element");
return "Wrong result of inserted element";
}
verif_tree(first);
}
// Try to add existing data
for (i = 0; i < MAX_ELEMENT; i++) {
if (!is_present(first, &(data[i]))) {
ELOG("Element is not present, it said! F**k");
return "Element is not present";
}
result = insert_elmt(first, &(data[i]), sizeof(int));
if (result != element_in_tree) {
ELOG("Wrong result of inserted element");
return "Wrong result of inserted element";
}
verif_tree(first);
}
// Try to delete it
delete_tree(first);
return NULL;
}
void test_convert_string_to_tree()
{
char input[9][104] = {"([8,8],[4,8],[2,4],[1,2],[3,2],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10],[14,12],[13,14],[15,14])",
"([8,8],[4,8],[2,4],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10],[14,12],[13,14],[15,14])",
"([8,8],[4,8],[2,4],[1,2],[3,2],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10])",
"([5,5],[4,5],[2,4],[1,4],[3,5],[6,3],[7,3])",
"([5,5],[4,5],[3,5],[6,3],[7,3])",
"([5,5],[4,5],[2,4],[1,4],[3,5])",
"([1,1],[2,1],[3,1])",
"([5,5])",
"([1,1],[2,1])"
};
char output[9][86] = {"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"8,4,2,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,-",
"5,4,2,$,1,$,3,6,$,7,$",
"5,4,$,3,6,$,7,$",
"5,4,2,$,1,$,3,$",
"1,2,$,3,$",
"5,$",
"1,2,$,-"
};
int iter_loop,index;
for(iter_loop=0;iter_loop<9;iter_loop++)
{
printf("%d-->",iter_loop+1);
if(input[iter_loop]==NULL || output[iter_loop]==NULL)
{
printf("INVALID INPUT");
continue;
}
NODE *root1;
root1 = driver_for_convert_string_to_tree(input[iter_loop]);
NODE *root2 = (NODE*)malloc(sizeof(NODE));
index = next_element_in_string(output[iter_loop],0);
root2->data = create_number(output[iter_loop],index);
index = next_element_in_string(output[iter_loop],index);
construct_tree(root2,output[iter_loop],index);
(tree_comparator(root1,root2)==1)?printf("ACCEPTED\n"):printf("REJECTED\n");
delete_tree(root1);
delete_tree(root2);
}
}
void QuadTreeNM::delete_tree(QuadTreeNodeNM* node_ptr)
{
if(node_ptr != NULL)
{
if(node_ptr->get_child_lt_ptr() != NULL)
delete_tree(node_ptr->get_child_lt_ptr());
if(node_ptr->get_child_rt_ptr() != NULL)
delete_tree(node_ptr->get_child_rt_ptr());
if(node_ptr->get_child_lb_ptr() != NULL)
delete_tree(node_ptr->get_child_lb_ptr());
if(node_ptr->get_child_rb_ptr() != NULL)
delete_tree(node_ptr->get_child_rb_ptr());
delete node_ptr;
if (node_ptr == root_ptr)
root_ptr = NULL;
}
}
