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; }
static int insert_int(BiTree *tree, int i) { BiTreeNode *node, *prev; int direction, *data; /***************************************************************************** * * * Insert i assuming a binary tree organized as a binary search tree. * * * *****************************************************************************/ node = tree->root; direction = 0; while (!bitree_is_eob(node)) { prev = node; if (i == *(int *)bitree_data(node)) { return -1; } else if (i < *(int *)bitree_data(node)) { node = bitree_left(node); direction = 1; } else { node = bitree_right(node); direction = 2; } } if ((data = (int *)malloc(sizeof(int))) == NULL) return -1; *data = i; if (direction == 0) return bitree_ins_left(tree, NULL, data); if (direction == 1) return bitree_ins_left(tree, prev, data); if (direction == 2) return bitree_ins_right(tree, prev, data); return -1; }
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; }
struct bitree *build(int n) { int i, *data; struct bitree *tree = NULL; struct bitree_node *position = NULL; tree = (struct bitree *) malloc(sizeof(struct bitree)); if (!tree) return NULL; bitree_init(tree, NULL); data = (int *) malloc(n * sizeof(int)); if (!data) { goto fail; } for (i = 0; i <= n/2; i++) { data[i] = i + 1; if (bitree_ins_left(tree, position, (const void *) &data[i]) != 0) goto fail; if (!position) { if (bitree_root(tree) == NULL) goto fail; position = bitree_root(tree); } else { position = position->left; } } position = bitree_root(tree); for (i = n/2 + 1; i < n; i++) { data[i] = i + 1; if (bitree_ins_right(tree, position, (const void *) &data[i]) != 0) goto fail; position = position->right; } return tree; fail: free(tree); return NULL; }
static int insert (BisTree *tree, BiTreeNode **node, const void *data, int *balanced) { AvlNode *avl_data; int cmpval, retval; /* Insert the data into the tree. */ if (bitree_is_eob (*node)) { /* Handle insertion into an empty tree. */ if ((avl_data = (AvlNode *) malloc (sizeof(AvlNode))) == NULL) return -1; avl_data->factor = AVL_BALANCED; avl_data->hidden = 0; avl_data->data = (void *) data; return bitree_ins_left (tree, *node, avl_data); } else { /* Handle insertion into a tree that is not empty. */ cmpval = tree->compare (data, ((AvlNode *) bitree_data (*node))->data); if (cmpval < 0) { /* Move to the left. */ if (bitree_is_eob (bitree_left (*node))) { if ((avl_data = (AvlNode *) malloc (sizeof(AvlNode))) == NULL) return -1; avl_data->factor = AVL_BALANCED; avl_data->hidden = 0; avl_data->data = (void *) data; if (bitree_ins_left (tree, *node, avl_data) != 0) return -1; *balanced = 0; } else { if ((retval = insert(tree, &bitree_left(*node), data, balanced)) != 0) { return retval; } } /* Ensure that the tree remains balanced. */ if (!(*balanced)) { switch (((AvlNode *) bitree_data (*node))->factor) { case AVL_LFT_HEAVY: rotate_left (node); *balanced = 1; break; case AVL_BALANCED: ((AvlNode *) bitree_data (*node))->factor = AVL_LFT_HEAVY; break; case AVL_RGT_HEAVY: ((AvlNode *) bitree_data (*node))->factor = AVL_BALANCED; *balanced = 1; } } } /* if (cmpval < 0) */ else if (cmpval > 0) { /* Move to the right. */ if (bitree_is_eob (bitree_right (*node))) { if ((avl_data = (AvlNode *) malloc (sizeof(AvlNode))) == NULL) return -1; avl_data->factor = AVL_BALANCED; avl_data->hidden = 0; avl_data->data = (void *) data; if (bitree_ins_right (tree, *node, avl_data) != 0) return -1; *balanced = 0; } else { if ((retval = insert (tree, &bitree_right (*node), data, balanced)) != 0) { return retval; } } /* Ensure that the tree remains balanced. */ if (!(*balanced)) { switch (((AvlNode *) bitree_data (*node))->factor) { case AVL_LFT_HEAVY: ((AvlNode *) bitree_data (*node))->factor = AVL_BALANCED; *balanced = 1; break; case AVL_BALANCED: ((AvlNode *) bitree_data (*node))->factor = AVL_RGT_HEAVY; break; case AVL_RGT_HEAVY: rotate_right (node); *balanced = 1; } } } /* if (cmpval > 0) */ else { /* Handle finding a copy of the data. */ if (!((AvlNode *) bitree_data (*node))->hidden) { /* Do nothing since the data is in the tree and not hidden. */ return 1; } else { /* Insert the new data and mark it as not hidden. */ if (tree->destroy != NULL) { /* Destroy the hidden data since it is being replaced. */ tree->destroy (((AvlNode *) bitree_data (*node))->data); } ((AvlNode *) bitree_data (*node))->data = (void *) data; ((AvlNode *) bitree_data (*node))->hidden = 0; /* Do not rebalance because the tree structure is unchanged. */ *balanced = 1; } } } return 0; }