C++ destroy_tree函数代码示例

void destroy_tree(struct tree_node *node,
		  tree_fn fnptr)
{
	if (node) {
		struct tree_node *left = node->left, *right = node->right;
		if (fnptr) {
			fnptr(node->data);
		}
		free(node);
		destroy_tree(left,fnptr);
		destroy_tree(right,fnptr);
	}
}

/* Deallocate all of the memory used by a BusinessNode BST, without memory
 * leaks.
 */
void destroy_tree(BusinessNode * root)
{
    if(root == NULL)
    {
        return;
    }
    destroy_tree(root->left);
    destroy_tree(root->right);
    free(root->name);
    free(root->stars);
    free(root->address);
    free(root);
}

void destroy_tree(BusinessNode * node)
{
    if(node == NULL)
	return;

    free(node -> name);
    free(node -> stars);
    free(node -> address);

    destroy_tree(node -> left);
    destroy_tree(node -> right);

    free(node);
}

void destroy_tree(Node * root)
{//recursively frees all memory associated with the binary tree
	if (root == NULL)
	{
		return;
	}

	destroy_tree(root -> left);
	destroy_tree(root -> right);

	free(root);

	return;
}

void destroy_tree(binary_tree_s* psNode)
{
	binary_tree_s** ppsCur;

	ppsCur = &psNode;

	if (*ppsCur != NULL)
	{
		destroy_tree((*ppsCur)->m_psLeftNode);	
		destroy_tree((*ppsCur)->m_psRightNode);	
		free((*ppsCur));
		ppsCur = NULL;
	}
}

void ADT::destroy_tree(Node *&leaf)
{
    if (leaf != NULL)
    {
        destroy_tree(leaf->left);
        destroy_tree(leaf->right);
        
        if (leaf->p != NULL)
        {
            delete leaf->p;
        }
        
        delete leaf;
        leaf = NULL;
    }
}

int	main(void)
{
	char	*key;
	char	*value;
	char	*tmp;
	int		read;
	t_node	*root;

	read = 1;
	root = 0;
	while (read)
	{
		get_next_line(0, &key);
		read = get_next_line(0, &value);
		if (!ft_strcmp(key, ""))
			read = 0;
		else
			add_node(&root, key, value);
	}
	if (*value)
	{
		search_key(root, value);
		while (get_next_line(0, &tmp) > 0)
			search_key(root, tmp);
	}
	destroy_tree(&root);
	return (0);
}

int main(int argc, char *argv[])
{
	struct rooted_tree *tree;	
	struct parameters params;
	static struct rooted_tree * (*process_tree)(struct rooted_tree *, set_t *);
	
	params = get_params(argc, argv);

	switch (params.mode) {
	case PRUNE_DIRECT:
		process_tree = process_tree_direct;
		break;
	case PRUNE_REVERSE:
		process_tree = process_tree_reverse;
		break;
	default:
		assert (0);
	}

	while (NULL != (tree = parse_tree())) {
		tree = process_tree(tree, params.prune_labels);
		dump_newick(tree->root);
		destroy_all_rnodes(NULL);
		destroy_tree(tree);
	}

	destroy_set(params.prune_labels);

	return 0;
}

static struct rooted_tree * process_tree_reverse(
		struct rooted_tree *tree, set_t *prune_labels)
{
	struct list_elem *el = tree->nodes_in_order->head;
	struct rnode *current;
	char *label;

	for (; NULL != el; el = el->next) {
		current = el->data;
		if (is_root(current)) break;
		label = current->label;
		/* mark this node (to keep it) if its label is on the CL */
		if (set_has_element(prune_labels, label)) {
			current->seen = true;
			struct prune_data *pdata =
				malloc(sizeof(struct prune_data));
			if (NULL == pdata) {perror(NULL); exit(EXIT_FAILURE); }
			pdata->kept_descendant = true;
			current->data = pdata;
		}
		/* and propagate 'seen' to parent (kept_descendant is
		 * propagated to children (not parents), see
		 * prune_predicate_keep_clade() */
		if (current->seen) {
			current->parent->seen = true;	/* inherit mark */
		}
	}

	struct rooted_tree *pruned = clone_tree_cond(tree,
			prune_predicate_keep_clade, prune_labels);	
	destroy_tree(tree);
	return pruned;
}

int main(int argc, char **argv)
{
    if(argc < 2)
    {
        printf("Usage: %s forwarding_table_file\n\n", argv[0]);
        exit(0);
    }

    FILE *fp = fopen(argv[1], "r");
    if(fp == NULL)
    {
        printf("Unable to open '%s'\n\n", argv[1]);
        exit(-1);
    }

    /* load the list file to a binary tree data structure */

    node * tree = loadToTree(fp, argv);

    /* ORTC - step 1: discard interior next-hops */

    clear_interior_next_hops(tree);

    /* ORTC - step 2: calculate most frequent next-hops by traversing bottom up */

    percolate_tree(tree);

    /* ORTC - step 3: */

    clean_redundancy(tree, NULL);


    /* print to file */

    char destination[128];
    sprintf(destination, "%s.compressed", argv[1]);
    FILE * destination_file = fopen(destination, "w");
    if(fp == NULL)
    {
        printf("Unable to open '%s'\n\n", argv[1]);
        exit(-1);
    }

    printToFile(tree, destination_file);

#ifdef DEBUG
    printf("final tree (pre-order traversal): ");
    print_tree(tree);
    puts("\n");
#endif

    destroy_tree(tree);
    LSTdestroy(queue, destroyItem);
    fclose(fp);
    fclose(destination_file);

    puts("done.\n");

    exit(0);
}

void c_test_ins_tree_height(void) {
  int sizeOfElement = sizeof(struct complexThing);
  Tree tree = new_tree(sizeOfElement, navigateComplex, copyComplex, destroyComplex, NULL);
  CU_ASSERT_TRUE(get_tree_height(tree) == 0);

  Complex *c = malloc(sizeof(struct complexThing));
  c->int_regular = 10;
  c->int_pointer = malloc(sizeof(int));
  *c->int_pointer = 15;

  tree_insert(&tree, c, NULL);

  CU_ASSERT_TRUE(get_tree_height(tree) == 1);

  if (tree != NULL) {
    destroy_tree(&tree); 
  }

  if (c != NULL) {
    if (c->int_pointer != NULL) {
      free(c->int_pointer);
    }

    free(c);
  }
 
}

void destroy_tree(node *root)
{
	node *n, *p;
	uint32_t i;

	for (n = root->children; n != NULL; n = p) {
		p = n->next;

		destroy_tree(n);
	}
	
	for (i = 0; i < root->n_attrs; ++i) {
		lwc_string_unref(root->attrs[i].name);
		lwc_string_unref(root->attrs[i].value);
	}
	free(root->attrs);

	if (root->classes != NULL) {
		for (i = 0; i < root->n_classes; ++i) {
			lwc_string_unref(root->classes[i]);
		}
		free(root->classes);
	}

	if (root->libcss_node_data != NULL) {
		css_libcss_node_data_handler(&select_handler, CSS_NODE_DELETED,
				NULL, root, NULL, root->libcss_node_data);
	}

	lwc_string_unref(root->name);
	free(root);
}

int main(int argc, char *argv[])
{
	struct rooted_tree *tree;	
	struct hash *rename_map;
	struct parameters params;
	
	params = get_params(argc, argv);

	rename_map = read_map(params.map_filename);

	while (NULL != (tree = parse_tree())) {
		process_tree(tree, rename_map, params);
		destroy_tree(tree, DONT_FREE_NODE_DATA);
	}

	struct llist *keys = hash_keys(rename_map);
	if (NULL == keys) { perror(NULL); exit(EXIT_FAILURE); }
	struct list_elem *e;
	for (e = keys->head; NULL != e; e = e->next) {
		char *key = (char *) e->data;
		char *val = hash_get(rename_map, key);
		free(val);
	}
	destroy_llist(keys);
	destroy_hash(rename_map);

	return 0;
}

void IntervalMap::freeIntervalMap() {
	/*for (int i = 0; i < numberOfIntervalls; i++) {
	 delete map[i];
	 }
	 delete[] this->map;*/
	destroy_tree(map);
}

void find_three_layer()
{
	int i=0;
	int j=0;
	int k=0;
	FILE *f_results;
	f_results = fopen(nondom_file, "a");
	for(i=1 ; i<=number_of_features ; i++)
	{
		current_round = i;
		printf("\n\n###################### ROUND %d ########################\n",i);
		find_a_layer();
		final_pareto_front();
		k=0;
		for(j=0 ; j<population_size ; j++)
		{
			if(dominated[j]==False)
			{
				pop[i][k].root = population[j].root;
				pop[i][k].fitness = population[j].fitness;
				pop[i][k].cost = population[j].cost;
				k++;
			}
			else
				destroy_tree(population[j].root);
		}
		pop_count[current_round]=k;
		fprintf(f_results,"\nthe number of solutions = %d\n",pop_count[current_round]);
	}
	fclose(f_results);
}