void enddown(){ bitree_destroy(bt); bitree_destroy(bt1); bitree_destroy(bt2); free(bt); free(bt1); free(bt2); for(int i=0; i<10; i++){ free(u[i]); } }
int main(int argc, char const *argv[]) { //create a unbalanced tree BiTree * unbalanced_tree = (BiTree*)malloc(sizeof(BiTree)); bitree_init(unbalanced_tree, NULL); int tree_node_index[5]; for (int i = 0; i < 5; ++i) { tree_node_index[i] = i; } BiTreeNode * position = NULL; bitree_ins_left(unbalanced_tree, NULL, (void *)&tree_node_index[0]); bitree_ins_left(unbalanced_tree, bitree_root(unbalanced_tree), (void *)&tree_node_index[1]); position = bitree_root(unbalanced_tree)->left; bitree_ins_left(unbalanced_tree, position, (void *)&tree_node_index[2]); position = position->left; bitree_ins_left(unbalanced_tree, position, (void *)&tree_node_index[3]); bitree_ins_right(unbalanced_tree, bitree_root(unbalanced_tree), (void *)&tree_node_index[4]); int balance_check_result = check_balance(bitree_root(unbalanced_tree)); if(balance_check_result < 0) printf("unbalanced tree\n"); else printf("balanced tree\n"); bitree_destroy(unbalanced_tree); free(unbalanced_tree); //create a balanced tree BiTree * balanced_tree = (BiTree *)malloc(sizeof(BiTree)); bitree_init(balanced_tree, NULL); bitree_ins_left(balanced_tree, NULL, (void *)&tree_node_index[0]); bitree_ins_left(balanced_tree, bitree_root(balanced_tree), (void *)&tree_node_index[1]); position = bitree_root(balanced_tree)->left; bitree_ins_left(balanced_tree, position, (void *)&tree_node_index[2]); bitree_ins_right(balanced_tree, position, (void *)&tree_node_index[3]); bitree_ins_right(balanced_tree, bitree_root(balanced_tree), (void *)&tree_node_index[4]); balance_check_result = check_balance(bitree_root(balanced_tree)); if(balance_check_result < 1) printf("unbalanced!\n"); else printf("balanced\n"); bitree_destroy(balanced_tree); free(balanced_tree); return 0; }
int bitree_merge(BiTree *merge, BiTree *left, BiTree *right, const void *data) { /* initialize the merged tree */ bitree_init(merge, left->destroy); /* insert the data for the root node of the merged tree */ if (bitree_insert_left(merge, NULL, data) != 0) { bitree_destroy(merge); return -1; } /* merge the two binary trees into a single binary tree */ bitree_root(merge)->left = bitree_root(left); bitree_root(merge)->right = bitree_root(right); /* adjust the size of the new binary tree */ merge->size = merge->size + bitree_size(left) + bitree_size(right); /* do not let the original trees access the merged nodes */ left->root = NULL; left->size = 0; right->root = NULL; right->size = 0; return 0; }
static void destroy_tree(void *tree) { /***************************************************************************** * Destroy and free one binary tree from the priority queue of trees. * *****************************************************************************/ bitree_destroy(tree); free(tree); return; }
int main(int argc, char *argv[]) { struct bitree *tree; int cnt; tree = build(DEFAULT_TREE_SIZE); if (!tree) { fprintf(stderr, "build tree error\n"); exit(EXIT_FAILURE); } traverse_dump(tree, TRAVE_PREORDER); traverse_dump(tree, TRAVE_INORDER); traverse_dump(tree, TRAVE_POSTORDER); traverse_dump(tree, TRAVE_LEVELORDER); fprintf(stdout, "\nmirroring the tree\n"); mirror(tree->root); traverse_dump(tree, TRAVE_LEVELORDER); mirror(tree->root); /* reverse */ fprintf(stdout, "\ndoubling the tree\n"); double_tree(tree); traverse_dump(tree, TRAVE_LEVELORDER); traverse_dump(tree, TRAVE_INORDER); traverse_dump(tree, TRAVE_PREORDER); cnt = print_paths(tree->root); fprintf(stdout, "total %d paths\n", cnt); exit: if (visit_list) dlist_destroy(visit_list); free(bitree_root(tree)->data); bitree_destroy(tree); free(tree); exit(EXIT_SUCCESS); }
int main(void) { BiTree * tree; char * a[] = {"kobe", "bryant", "james", "jordan", "johnson"}; List *list; ListNode *node; tree = (BiTree *) malloc(sizeof(BiTree)); if (tree == NULL) return -1; list = (List *) malloc(sizeof(List)); if (list == NULL) return -1; bitree_init(tree, &data_destroy); bitree_ins_left(tree, NULL, a[0]); bitree_ins_left(tree, tree->root, a[1]); bitree_ins_right(tree, tree->root, a[2]); bitree_ins_left(tree, tree->root->left, a[3]); bitree_ins_right(tree, tree->root->left, a[4]); //list init list_init(list, &data_destroy); postorder(tree->root, list); node = list->head; while(node != NULL) { printf("%s\n", (char *) node->data ); node = node->next; } bitree_destroy(tree); list_destroy(list); return 0; }
void bitree_avl_test() { BiTree_AVL bitree; bitree_avl_init(&bitree, (void *) studn_compare, (void *) studn_destroy); bitree_avl_insert(&bitree, studn_get_init(1, "zhangsan", 1, 32, 9)); bitree_avl_insert(&bitree, studn_get_init(2, "lisi", 1, 32, 8)); bitree_avl_insert(&bitree, studn_get_init(3, "wangdazhui", 1, 32, 9)); bitree_avl_insert(&bitree, studn_get_init(4, "zhangquandan", 1, 32, 10)); bitree_avl_insert(&bitree, studn_get_init(5, "zhangfei", 1, 32, 9)); bitree_avl_insert(&bitree, studn_get_init(6, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(7, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(8, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(9, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(10, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(11, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(12, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(13, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(14, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(15, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(16, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(17, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(18, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(19, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(20, "liucuihua", 0, 22, 11)); bitree_avl_insert(&bitree, studn_get_init(21, "liucuihua", 0, 22, 11)); printf("%s%d\n", "bitree avl size :", bitree_avl_size(&bitree)); BiTreeNode *node = bitree_root(&bitree); printBitree(node); printf("\n"); printf("%s\n", "============== release data begin ==============="); bitree_destroy(&bitree); printf("%s\n", "============== release data end ==============="); }
static int build_tree(int *freqs, BiTree **tree) { BiTree *init, *merge, *left, *right; PQueue pqueue; HuffNode *data; int size, c; /***************************************************************************** * * * Initialize the priority queue of binary trees. * * * *****************************************************************************/ *tree = NULL; pqueue_init(&pqueue, compare_freq, destroy_tree); for (c = 0; c <= UCHAR_MAX; c++) { if (freqs[c] != 0) { /*********************************************************************** * * * Set up a binary tree for the current symbol and its frequency. * * * ***********************************************************************/ if ((init = (BiTree *)malloc(sizeof(BiTree))) == NULL) { pqueue_destroy(&pqueue); return -1; } bitree_init(init, free); if ((data = (HuffNode *)malloc(sizeof(HuffNode))) == NULL) { pqueue_destroy(&pqueue); return -1; } data->symbol = c; data->freq = freqs[c]; if (bitree_ins_left(init, NULL, data) != 0) { free(data); bitree_destroy(init); free(init); pqueue_destroy(&pqueue); return -1; } /*********************************************************************** * * * Insert the binary tree into the priority queue. * * * ***********************************************************************/ if (pqueue_insert(&pqueue, init) != 0) { bitree_destroy(init); free(init); pqueue_destroy(&pqueue); return -1; } } } /***************************************************************************** * * * Build a Huffman tree by merging trees in the priority queue. * * * *****************************************************************************/ size = pqueue_size(&pqueue); for (c = 1; c <= size - 1; c++) { /************************************************************************** * * * Allocate storage for the next merged tree. * * * **************************************************************************/ if ((merge = (BiTree *)malloc(sizeof(BiTree))) == NULL) { pqueue_destroy(&pqueue); return -1; } /************************************************************************** * * * Extract the two trees whose root nodes have the smallest frequencies. * * * **************************************************************************/ if (pqueue_extract(&pqueue, (void **)&left) != 0) { pqueue_destroy(&pqueue); free(merge); return -1; } if (pqueue_extract(&pqueue, (void **)&right) != 0) { pqueue_destroy(&pqueue); free(merge); return -1; } /************************************************************************** * * * Allocate storage for the data in the root node of the merged tree. * * * **************************************************************************/ if ((data = (HuffNode *)malloc(sizeof(HuffNode))) == NULL) { pqueue_destroy(&pqueue); free(merge); return -1; } memset(data, 0, sizeof(HuffNode)); /************************************************************************** * * * Sum the frequencies in the root nodes of the trees being merged. * * * **************************************************************************/ data->freq = ((HuffNode *)bitree_data(bitree_root(left)))->freq + ((HuffNode *)bitree_data(bitree_root(right)))->freq; /************************************************************************** * * * Merge the two trees. * * * **************************************************************************/ if (bitree_merge(merge, left, right, data) != 0) { pqueue_destroy(&pqueue); free(merge); return -1; } /************************************************************************** * * * Insert the merged tree into the priority queue and free the others. * * * **************************************************************************/ if (pqueue_insert(&pqueue, merge) != 0) { pqueue_destroy(&pqueue); bitree_destroy(merge); free(merge); return -1; } free(left); free(right); } /***************************************************************************** * * * The last tree in the priority queue is the Huffman tree. * * * *****************************************************************************/ if (pqueue_extract(&pqueue, (void **)tree) != 0) { pqueue_destroy(&pqueue); return -1; } else { pqueue_destroy(&pqueue); } return 0; }
int huffman_uncompress(const unsigned char *compressed, unsigned char **original) { BiTree *tree; BiTreeNode *node; int freqs[UCHAR_MAX + 1], hsize, size, ipos, opos, state, c; unsigned char *orig, *temp; /***************************************************************************** * * * Initially there is no buffer of original data. * * * *****************************************************************************/ *original = orig = NULL; /***************************************************************************** * * * Get the header information from the buffer of compressed data. * * * *****************************************************************************/ hsize = sizeof(int) + (UCHAR_MAX + 1); memcpy(&size, compressed, sizeof(int)); for (c = 0; c <= UCHAR_MAX; c++) freqs[c] = compressed[sizeof(int) + c]; /***************************************************************************** * * * Rebuild the Huffman tree used previously to compress the data. * * * *****************************************************************************/ if (build_tree(freqs, &tree) != 0) return -1; /***************************************************************************** * * * Uncompress the data. * * * *****************************************************************************/ ipos = hsize * 8; opos = 0; node = bitree_root(tree); while (opos < size) { /************************************************************************** * * * Get the next bit in the compressed data. * * * **************************************************************************/ state = bit_get(compressed, ipos); ipos++; if (state == 0) { /*********************************************************************** * * * Move to the left. * * * ***********************************************************************/ if (bitree_is_eob(node) || bitree_is_eob(bitree_left(node))) { bitree_destroy(tree); free(tree); return -1; } else node = bitree_left(node); } else { /*********************************************************************** * * * Move to the right. * * * ***********************************************************************/ if (bitree_is_eob(node) || bitree_is_eob(bitree_right(node))) { bitree_destroy(tree); free(tree); return -1; } else node = bitree_right(node); } if (bitree_is_eob(bitree_left(node))&&bitree_is_eob(bitree_right(node))) { /*********************************************************************** * * * Write the symbol in the leaf node to the buffer of original data. * * * ***********************************************************************/ if (opos > 0) { if ((temp = (unsigned char *)realloc(orig, opos + 1)) == NULL) { bitree_destroy(tree); free(tree); free(orig); return -1; } orig = temp; } else { if ((orig = (unsigned char *)malloc(1)) == NULL) { bitree_destroy(tree); free(tree); return -1; } } orig[opos] = ((HuffNode *)bitree_data(node))->symbol; opos++; /*********************************************************************** * * * Move back to the top of the tree. * * * ***********************************************************************/ node = bitree_root(tree); } } bitree_destroy(tree); free(tree); /***************************************************************************** * * * Point to the buffer of original data. * * * *****************************************************************************/ *original = orig; /***************************************************************************** * * * Return the number of bytes in the original data. * * * *****************************************************************************/ return opos; }
int huffman_compress(const unsigned char *original, unsigned char **compressed, int size) { BiTree *tree; HuffCode table[UCHAR_MAX + 1]; int freqs[UCHAR_MAX + 1], max, scale, hsize, ipos, opos, cpos, c, i; unsigned char *comp, *temp; /***************************************************************************** * * * Initially there is no buffer of compressed data. * * * *****************************************************************************/ *compressed = NULL; /***************************************************************************** * * * Get the frequency of each symbol in the original data. * * * *****************************************************************************/ for (c = 0; c <= UCHAR_MAX; c++) freqs[c] = 0; ipos = 0; if (size > 0) { while (ipos < size) { freqs[original[ipos]]++; ipos++; } } /***************************************************************************** * * * Scale the frequencies to fit into one byte. * * * *****************************************************************************/ max = UCHAR_MAX; for (c = 0; c <= UCHAR_MAX; c++) { if (freqs[c] > max) max = freqs[c]; } for (c = 0; c <= UCHAR_MAX; c++) { scale = (int)(freqs[c] / ((double)max / (double)UCHAR_MAX)); if (scale == 0 && freqs[c] != 0) freqs[c] = 1; else freqs[c] = scale; } /***************************************************************************** * * * Build the Huffman tree and table of codes for the data. * * * *****************************************************************************/ if (build_tree(freqs, &tree) != 0) return -1; for (c = 0; c <= UCHAR_MAX; c++) memset(&table[c], 0, sizeof(HuffCode)); build_table(bitree_root(tree), 0x0000, 0, table); bitree_destroy(tree); free(tree); /***************************************************************************** * * * Write the header information. * * * *****************************************************************************/ hsize = sizeof(int) + (UCHAR_MAX + 1); if ((comp = (unsigned char *)malloc(hsize)) == NULL) return -1; memcpy(comp, &size, sizeof(int)); for (c = 0; c <= UCHAR_MAX; c++) comp[sizeof(int) + c] = (unsigned char)freqs[c]; /***************************************************************************** * * * Compress the data. * * * *****************************************************************************/ ipos = 0; opos = hsize * 8; while (ipos < size) { /************************************************************************** * * * Get the next symbol in the original data. * * * **************************************************************************/ c = original[ipos]; /************************************************************************** * * * Write the code for the symbol to the buffer of compressed data. * * * **************************************************************************/ for (i = 0; i < table[c].size; i++) { if (opos % 8 == 0) { /******************************************************************** * * * Allocate another byte for the buffer of compressed data. * * * ********************************************************************/ if ((temp = (unsigned char *)realloc(comp,(opos / 8) + 1)) == NULL) { free(comp); return -1; } comp = temp; } cpos = (sizeof(short) * 8) - table[c].size + i; bit_set(comp, opos, bit_get((unsigned char *)&table[c].code, cpos)); opos++; } ipos++; } /***************************************************************************** * * * Point to the buffer of compressed data. * * * *****************************************************************************/ *compressed = comp; /***************************************************************************** * * * Return the number of bytes in the compressed data. * * * *****************************************************************************/ return ((opos - 1) / 8) + 1; }
int main(int argc, char **argv) { BiTree tree; BiTreeNode *node; int i; /***************************************************************************** * * * Initialize the binary tree. * * * *****************************************************************************/ bitree_init(&tree, free); /***************************************************************************** * * * Perform some binary tree operations. * * * *****************************************************************************/ fprintf(stdout, "Inserting some nodes\n"); if (insert_int(&tree, 20) != 0) return 1; if (insert_int(&tree, 10) != 0) return 1; if (insert_int(&tree, 30) != 0) return 1; if (insert_int(&tree, 15) != 0) return 1; if (insert_int(&tree, 25) != 0) return 1; if (insert_int(&tree, 70) != 0) return 1; if (insert_int(&tree, 80) != 0) return 1; if (insert_int(&tree, 23) != 0) return 1; if (insert_int(&tree, 26) != 0) return 1; if (insert_int(&tree, 5) != 0) return 1; fprintf(stdout, "Tree size is %d\n", bitree_size(&tree)); fprintf(stdout, "(Preorder traversal)\n"); print_preorder(bitree_root(&tree)); i = 30; if ((node = search_int(&tree, i)) == NULL) { fprintf(stdout, "Could not find %03d\n", i); } else { fprintf(stdout, "Found %03d...Removing the left tree below it\n", i); bitree_rem_left(&tree, node); fprintf(stdout, "Tree size is %d\n", bitree_size(&tree)); fprintf(stdout, "(Preorder traversal)\n"); print_preorder(bitree_root(&tree)); } i = 99; if ((node = search_int(&tree, i)) == NULL) { fprintf(stdout, "Could not find %03d\n", i); } else { fprintf(stdout, "Found %03d...Removing the right tree below it\n", i); bitree_rem_right(&tree, node); fprintf(stdout, "Tree size is %d\n", bitree_size(&tree)); fprintf(stdout, "(Preorder traversal)\n"); print_preorder(bitree_root(&tree)); } i = 20; if ((node = search_int(&tree, i)) == NULL) { fprintf(stdout, "Could not find %03d\n", i); } else { fprintf(stdout, "Found %03d...Removing the right tree below it\n", i); bitree_rem_right(&tree, node); fprintf(stdout, "Tree size is %d\n", bitree_size(&tree)); fprintf(stdout, "(Preorder traversal)\n"); print_preorder(bitree_root(&tree)); } i = bitree_is_leaf(bitree_root(&tree)); fprintf(stdout, "Testing bitree_is_leaf...Value=%d (0=OK)\n", i); i = bitree_is_leaf(bitree_left((bitree_root(&tree)))); fprintf(stdout, "Testing bitree_is_leaf...Value=%d (0=OK)\n", i); i = bitree_is_leaf(bitree_left(bitree_left((bitree_root(&tree))))); fprintf(stdout, "Testing bitree_is_leaf...Value=%d (1=OK)\n", i); i = bitree_is_leaf(bitree_right(bitree_left((bitree_root(&tree))))); fprintf(stdout, "Testing bitree_is_leaf...Value=%d (1=OK)\n", i); fprintf(stdout, "Inserting some nodes\n"); if (insert_int(&tree, 55) != 0) return 1; if (insert_int(&tree, 44) != 0) return 1; if (insert_int(&tree, 77) != 0) return 1; if (insert_int(&tree, 11) != 0) return 1; fprintf(stdout, "Tree size is %d\n", bitree_size(&tree)); fprintf(stdout, "(Preorder traversal)\n"); print_preorder(bitree_root(&tree)); fprintf(stdout, "(Inorder traversal)\n"); print_inorder(bitree_root(&tree)); fprintf(stdout, "(Postorder traversal)\n"); print_postorder(bitree_root(&tree)); /***************************************************************************** * * * Destroy the binary tree. * * * *****************************************************************************/ fprintf(stdout, "Destroying the tree\n"); bitree_destroy(&tree); return 0; }
int bi_search_tree_destroy(BI_S_TREE *b) { return bitree_destroy(b); }
int avltree_destroy(AVLTREE *b) { return bitree_destroy(b); }