static void preorder_tree(const BiTreeNode *node) {
/*****************************************************************************
* *
* Display the binary search tree rooted at the specified node. *
* *
*****************************************************************************/
if (!bitree_is_eob(node)) {
fprintf(stdout, "Node=%s, %+2d, hidden=%d\n", (char *)((AvlNode *)
bitree_data(node))->data, ((AvlNode *)bitree_data(node))->factor,
((AvlNode *)bitree_data(node))->hidden);
if (!bitree_is_eob(bitree_left(node)))
preorder_tree(bitree_left(node));
if (!bitree_is_eob(bitree_right(node)))
preorder_tree(bitree_right(node));
}
return;
}
int postorder(const BiTreeNode *node, List *list) {
/*****************************************************************************
* *
* Load the list with a postorder listing of the tree. *
* *
*****************************************************************************/
if (!bitree_is_eob(node)) {
if (!bitree_is_eob(bitree_left(node)))
if (postorder(bitree_left(node), list) != 0)
return -1;
if (!bitree_is_eob(bitree_right(node)))
if (postorder(bitree_right(node), list) != 0)
return -1;
if (list_ins_next(list, list_tail(list), bitree_data(node)) != 0)
return -1;
}
return 0;
}
/**
* 前序遍历二叉树
*/
int preorder(const BiTreeNode *node, List *list) {
if (!bitree_is_eob(node)) {
if (list_ins_next(list, list_tail(list), bitree_data(node)) != 0) {
printf("%s\n", "preorder() insert node into list fail.");
return -1;
}
//不是没有下级节点的节点
if (!bitree_is_eob(bitree_left(node))) {
if (preorder(bitree_left(node), list) != 0) { //递归调用
printf("%s\n", "preorder() left tree order fail.");
return -1;
}
if(!bitree_is_eob(bitree_right(node))) {
if(preorder(bitree_right(node), list) != 0) {//递归调用
printf("%s\n", "preorder() right tree order end.");
return -1;
}
}
}
}
return 0;
}
int preorder (const BiTreeNode *node, List *list)
{
if (!bitree_is_eob(node)) {
// problem with insert data into list
if (list_ins_next(list, list_tail(list), bitree_data(node)) != 0) {
return -1;
}
// traverse the non-NULL left node
if (!bitree_is_eob(bitree_left(node))) {
if (preorder(bitree_left(node), list) != 0) {
return -1;
}
}
// traverse the non_NULL right node
if (!bitree_is_eob(bitree_right(node))) {
if (preorder(bitree_right(node), list) != 0) {
return -1;
}
}
}
return 0;
}
static void build_table(BiTreeNode *node, unsigned short code, unsigned char
size, HuffCode *table) {
if (!bitree_is_eob(node)) {
if (!bitree_is_eob(bitree_left(node))) {
/***********************************************************************
* *
* Move to the left and append 0 to the current code. *
* *
***********************************************************************/
build_table(bitree_left(node), code << 1, size + 1, table);
}
if (!bitree_is_eob(bitree_right(node))) {
/***********************************************************************
* *
* Move to the right and append 1 to the current code. *
* *
***********************************************************************/
build_table(bitree_right(node), (code << 1) | 0x0001, size + 1, table);
}
if (bitree_is_eob(bitree_left(node))&&bitree_is_eob(bitree_right(node))) {
/***********************************************************************
* *
* Ensure that the current code is in big-endian format. *
* *
***********************************************************************/
code = htons(code);
/***********************************************************************
* *
* Assign the current code to the symbol in the leaf node. *
* *
***********************************************************************/
table[((HuffNode *)bitree_data(node))->symbol].used = 1;
table[((HuffNode *)bitree_data(node))->symbol].code = code;
table[((HuffNode *)bitree_data(node))->symbol].size = size;
}
}
return;
}
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;
}
/* Insert a node to be the left child of the tree */
void bitree_ins_left(BiTree * tree, BiTreeNode * node, const void *data) {
BitTreeNode * new_node, ** position;
// Allowed to add a empty tree
if (node == NULL) {
if (bitree_size(tree) > 1) {
printf ("The tree node is empty.\n");
return -1;
}
positon = & tree -> root;
}
else {
if (bitree_left(node) != NULL) {
printf ("This node already have a left child.\n");
return -1;
}
position = & node -> left;
}
if ((new_node = (BiTreeNode *) malloc (sizeof(BiTreeNode))) == NULL) {
printf ("Can't create a new node.\n");
return -1;
}
new_node -> left = NULL;
new_node -> right= NULL;
new_node -> data = (void *) data;
*postion == new_node;
tree -> size ++;
}
void
print_nodechildren(const BiTreeNode *node) {
printf("%s\t\t\t%s\t\t\t",
((!bitree_is_eob(bitree_right(node))) ?
((char *)((TNode *)((AvlNode *)
bitree_data(bitree_right(node)))->data)->vname) :
"NIL"),
((!bitree_is_eob(bitree_left(node))) ?
((char *)((TNode *)((AvlNode *)
bitree_data(bitree_left(node)))->data)->vname) :
"NIL")
);
return;
};
int bitree_ins_left(BiTree * tree, BiTreeNode * node, const void *data)
{
BiTreeNode *new_node, **position;
/*****************************************************************************
* Determine where to insert the node. *
*****************************************************************************/
if (node == NULL) {
/**************************************************************************
* Allow insertion at the root only in an empty tree. *
**************************************************************************/
if (bitree_size(tree) > 0)
return -1;
position = &tree->root;
}
else {
/**************************************************************************
* Normally allow insertion only at the end of a branch. *
**************************************************************************/
if (bitree_left(node) != NULL)
return -1;
position = &node->left;
}
/*****************************************************************************
* Allocate storage for the node. *
*****************************************************************************/
if ((new_node = (BiTreeNode *) malloc(sizeof(BiTreeNode))) == NULL)
return -1;
/*****************************************************************************
* Insert the node into the tree. *
*****************************************************************************/
new_node->data = (void *)data;
new_node->left = NULL;
new_node->right = NULL;
*position = new_node;
/*****************************************************************************
* Adjust the size of the tree to account for the inserted node. *
*****************************************************************************/
tree->size++;
return 0;
}
/* 后序遍历 */
int postorder(const BiTreeNode *node, List *list) {
if (!bitree_is_eob(node)) {
/* 左 */
if (!bitree_is_eob(bitree_left(node)))
if (postorder(bitree_left(node), list) != 0)
return -1;
/* 右 */
if (!bitree_is_eob(bitree_right(node)))
if (postorder(bitree_right(node), list) != 0)
return -1;
/* 根 */
if (list_ins_next(list, list_tail(list), bitree_data(node)) != 0)
return -1;
}
return 0;
}
static int
hide (BisTree *tree, BiTreeNode *node, const void *data)
{
int cmpval, retval;
if (bitree_is_eob (node))
{
/* Return that the data was not found. */
return -1;
}
cmpval = tree->compare (data, ((AvlNode *) bitree_data (node))->data);
if (cmpval < 0)
{
/* Move to the left. */
retval = hide (tree, bitree_left (node), data);
}
else if (cmpval > 0)
{
/* Move to the right. */
retval = hide (tree, bitree_right (node), data);
}
else
{
/* Mark the node as hidden. */
((AvlNode *) bitree_data (node))->hidden = 1;
retval = 0;
}
return retval;
}
static void
rotate_left (BiTreeNode **node)
{
BiTreeNode *left, *grandchild;
left = bitree_left (*node);
if (((AvlNode *) bitree_data (left))->factor == AVL_LFT_HEAVY)
{
/* Perform an LL rotation. */
bitree_left (*node) = bitree_right (left);
bitree_right (left) = *node;
((AvlNode *) bitree_data (*node))->factor = AVL_BALANCED;
((AvlNode *) bitree_data (left))->factor = AVL_BALANCED;
*node = left;
}
else
{
/* Perform an LR rotation. */
grandchild = bitree_right (left);
bitree_right (left) = bitree_left (grandchild);
bitree_left (grandchild) = left;
bitree_left (*node) = bitree_right (grandchild);
bitree_right (grandchild) = *node;
switch (((AvlNode *) bitree_data (grandchild))->factor)
{
case AVL_LFT_HEAVY:
((AvlNode *) bitree_data (*node))->factor = AVL_RGT_HEAVY;
((AvlNode *) bitree_data (left))->factor = AVL_BALANCED;
break;
case AVL_BALANCED:
((AvlNode *) bitree_data (*node))->factor = AVL_BALANCED;
((AvlNode *) bitree_data (left))->factor = AVL_BALANCED;
break;
case AVL_RGT_HEAVY:
((AvlNode *) bitree_data (*node))->factor = AVL_BALANCED;
((AvlNode *) bitree_data (left))->factor = AVL_LFT_HEAVY;
break;
}
((AvlNode *) bitree_data (grandchild))->factor = AVL_BALANCED;
*node = grandchild;
}
return;
}
int
postorder(const BiTreeNode *node) {
if (!bitree_is_eob(node)) {
if (!bitree_is_eob(bitree_left(node)))
if(postorder(bitree_left(node)) != 0)
return(-1);
if (!bitree_is_eob(bitree_right(node)))
if(postorder(bitree_right(node)) != 0)
return(-1);
fprintf(stdout, "Node=%s (size: %d), %+2d, hidden=%d\n",
(char *)((TNode *)((AvlNode *)bitree_data(node))->data)->vname,
list_size((List *)((TNode *)((AvlNode *)bitree_data(node))->data)->appear),
((AvlNode *)bitree_data(node))->factor,
((AvlNode *)bitree_data(node))->hidden);
}
return(0);
}
int inorder(const BiTreeNode *node, List *list)
{
if(!bitree_is_eob(node))
{
if(!bitree_is_eob(bitree_left(node)))
{
if(inorder(bitree_left(node), list) != 0)
return -1;
}
if(list_ins_next(list, list_tail(list), bitree_data(node)) != 0)
return -1;
if(!bitree_is_eob(bitree_right(node)))
{
if(inorder(bitree_right(node), list) != 0)
return -1;
}
}
return 0;
}
/**
* 后序遍历二叉树
*/
int postorder(const BiTreeNode *node, List *list){
if(!bitree_is_eob(node)){
if(!bitree_is_eob(bitree_left(node))){
if(inorder(bitree_left(node), list) != 0){
printf("%s\n","postorder() left tree order end");
return -1;
}
}
if(!bitree_is_eob(bitree_right(node))){
if(inorder(bitree_right(node), list) != 0){
printf("%s\n", "postorder() right tree order end");
return -1;
}
}
if(list_ins_next(list, list_tail(list), bitree_data(node)) != 0){
printf("%s\n", "postorder() add node to list fail.");
return -1;
}
}
return 0;
}
int
inorder(const BiTreeNode *node, void (*display_node)(const BiTreeNode *node)){
if (!bitree_is_eob(node)) {
if (!bitree_is_eob(bitree_left(node)))
if(inorder(bitree_left(node), display_node) != 0)
return(-1);
display_node(node);
/*
fprintf(stdout, "Node=%s (size: %d), %+2d, hidden=%d\n",
(char *)((TNode *)((AvlNode *)bitree_data(node))->data)->vname,
list_size((List *)((TNode *)((AvlNode *)bitree_data(node))->data)->appear),
((AvlNode *)bitree_data(node))->factor,
((AvlNode *)bitree_data(node))->hidden);
*/
if (!bitree_is_eob(bitree_right(node)))
if(inorder(bitree_right(node), display_node) != 0)
return(-1);
}
return(0);
}
static void print_postorder(const BiTreeNode *node) {
/*****************************************************************************
* *
* Display the binary tree rooted at the specified node in postorder. *
* *
*****************************************************************************/
if (!bitree_is_eob(node)) {
if (!bitree_is_eob(bitree_left(node)))
print_postorder(bitree_left(node));
if (!bitree_is_eob(bitree_right(node)))
print_postorder(bitree_right(node));
fprintf(stdout, "Node=%03d\n", *(int *)bitree_data(node));
}
return;
}
static void rotate_left(BiTreeNode **node) {
BiTreeNode *left, *grandchild;
left = bitree_left(*node);
// LL rotate
if (((AvlTreeNode *)bitree_data(left))->factor == AVL_LEFT_HEAVY) {
bitree_left(*node) = bitree_right(left);
bitree_right(left) = *node;
((AvlTreeNode *)bitree_data(*node))->factor = AVL_BALANCED;
((AvlTreeNode *)bitree_data(left))->factor = AVL_BALANCED;
*node = left;
// LR rotate
} else {
grandchild = bitree_right(left);
bitree_right(left) = bitree_left(grandchild);
bitree_left(grandchild) = left;
bitree_left(*node) = bitree_right(grandchild);
bitree_right(grandchild) = *node;
switch (((AvlTreeNode *)bitree_data(grandchild))->factor) {
case AVL_LEFT_HEAVY:
((AvlTreeNode *)bitree_data(*node))->factor = AVL_RIGHT_HEAVY;
((AvlTreeNode *)bitree_data(left))->factor = AVL_BALANCED;
break;
case AVL_BALANCED:
((AvlTreeNode *)bitree_data(*node))->factor = AVL_BALANCED;
((AvlTreeNode *)bitree_data(left))->factor = AVL_BALANCED;
break;
case AVL_RIGHT_HEAVY:
((AvlTreeNode *)bitree_data(*node))->factor = AVL_BALANCED;
((AvlTreeNode *)bitree_data(left))->factor = AVL_LEFT_HEAVY;
break;
}
((AvlTreeNode *)bitree_data(grandchild))->factor = AVL_BALANCED;
*node = grandchild;
}
return;
}
static int lookup (AvlTree *tree, BiTreeNode *node, void **data) {
int cmpval, retval = -1;
if (bitree_is_eob(tree))
return retval;
cmpval = tree->compare(*data, ((AvlTreeNode *)bitree_data(node))->data);
if (cmpval < 0) {
retval = lookup(tree, bitree_left(node), data);
} else if (cmpval > 0) {
retval = lookup(tree, bitree_right(node), data);
} else {
if (!((AvlTreeNode *)bitree_data(node))->hidden) {
*data = ((AvlTreeNode *)bitree_data(node))->data;
retval = 0;
} else {
retval = -1;
}
}
return retval;
}
static int
lookup (BisTree *tree, BiTreeNode *node, void **data)
{
int cmpval, retval;
if (bitree_is_eob (node))
{
/* Return that the data was not found. */
return -1;
}
cmpval = tree->compare (*data, ((AvlNode *) bitree_data (node))->data);
if (cmpval < 0)
{
/* Move to the left. */
retval = lookup (tree, bitree_left (node), data);
}
else if (cmpval > 0)
{
/* Move to the right. */
retval = lookup (tree, bitree_right (node), data);
}
else
{
if (!((AvlNode *) bitree_data (node))->hidden)
{
/* Pass back the data from the tree. */
*data = ((AvlNode *) bitree_data (node))->data;
retval = 0;
}
else
{
/* Return that the data was not found. */
return -1;
}
}
return retval;
}
static BiTreeNode *search_int(BiTree *tree, int i) {
BiTreeNode *node;
/*****************************************************************************
* *
* Look up i assuming a binary tree organized as a binary search tree. *
* *
*****************************************************************************/
node = bitree_root(tree);
while (!bitree_is_eob(node)) {
if (i == *(int *)bitree_data(node)) {
return node;
}
else if (i < *(int *)bitree_data(node)) {
node = bitree_left(node);
}
else {
node = bitree_right(node);
}
}
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;
}
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;
}
static int insert(Bitree *tree, BiTreeNode **node, const void *data, int *balanced) {
AvlTreeNode *avlnode;
int result, compare;
if (bitree_is_eob(*node)) {
if ((avlnode = (AvlTreeNode *)malloc(sizeof(AvlTreeNode))) == NULL)
return -1;
avlnode->factor = 0;
avlnode->data = (void *)data;
avlnode->hidden = 0;
return bitree_insert_left(tree, *node, avlnode);
} else {
compare = tree->compare(data, ((AvlTreeNode *)bitree_data(*node))->data);
if (compare < 0) {
if (bitree_is_eob(bitree_left(*node))) {
if ((avlnode = (AvlTreeNode *)malloc(sizeof(AvlTreeNode))) == NULL)
return -1;
avlnode->factor = 0;
avlnode->data = (void *)data;
avlnode->hidden = 0;
if (bitree_insert_left(tree, *node, avlnode) != 0)
return -1;
*balanced = 0;
} else {
if ((result = insert(tree, &bitree_left(*node), data, balanced)) != 0) {
return result;
}
}
if (!(*balanced)) {
switch (((AvlTreeNode *)bitree_data(*node))->factor) {
case AVL_LEFT_HEAVY:
rotate_left(node);
*balanced = 1;
break;
case AVL_BALANCED:
((AvlTreeNode *)bitree_data(*node))->factor = AVL_LEFT_HEAVY;
break;
case AVL_RIGHT_HEAVY:
((AvlTreeNode *)bitree_data(*node))->factor = AVL_BALANCED;
*balanced = 1;
break;
}
}
} else if (compare > 0) {
if (bitree_is_eob(bitree_right(*node))) {
if ((avlnode = (AvlTreeNode *)malloc(sizeof(AvlTreeNode))) == NULL)
return -1;
avlnode->factor = 0;
avlnode->data = (void *)data;
avlnode->hidden = 0;
if (bitree_insert_right(tree, *node, avlnode) != 0)
return -1;
*balanced = 0;
} else {
if ((result = insert(tree, &bitree_right(*node), data, balanced)) != 0) {
return result;
}
}
if (!(*balanced)) {
switch (((AvlTreeNode *)bitree_data(*node))->factor) {
case AVL_LEFT_HEAVY:
((AvlTreeNode *)bitree_data(*node))->factor = AVL_BALANCED;
*balanced = 1;
break;
case AVL_BALANCED:
((AvlTreeNode *)bitree_data(*node))->factor = AVL_RIGHT_HEAVY;
break;
case AVL_RIGHT_HEAVY:
rotate_right(node);
*balanced = 1;
break;
}
}
} else {
if (!((AvlTreeNode *)bitree_data(*node))->hidden) {
return 1;
} else {
if (tree->destory != NULL)
tree->destory(((AvlTreeNode *)bitree_data(*node))->data);
((AvlTreeNode *)bitree_data(*node))->data = (void *)data;
((AvlTreeNode *)bitree_data(*node))->hidden = 0;
*balanced = 1;
}
}
}
return 0;
}
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;
}
