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