AVL平衡二叉树 -构建

/* 表示二叉树最大高度 */
#define BITREE_MAX_HEIGHT   32


typedef int (*BITREE_VISIT_CB)(void *);
typedef int (*BITREE_CMP_CB)(void *, void *);


struct bitree_node_t
{
    struct bitree_node_t *lchild;
    struct bitree_node_t *rchild;
    struct bitree_node_t *parent;
    int balancefactor;     //平衡因子
    void *data;
};

struct bitree_t
{
    /* 指向根结点 */
    struct bitree_node_t *root;
    int count;
    BITREE_CMP_CB cmp;
};

/* 构造空树 */

int InitBiTree(struct bitree_t *tree, BITREE_CMP_CB hook)
{
    if (tree)
    {
        memset(tree, 0, sizeof(struct bitree_t));
        tree->cmp = hook;
    }

    return 0;
}

/* 创建一棵空树 hook为初始化树的比较函数cmp */

struct bitree_t *CreateBiTree(BITREE_CMP_CB hook)
{
    struct bitree_t *tree = NULL;

    tree = (struct bitree_t *)malloc(sizeof(struct bitree_t));
    if (tree)
    {
        memset(tree, 0, sizeof(struct bitree_t));
        tree->cmp = hook;
    }
    return tree;
}

/* 删除每一个结点 - 后根遍历 - 递归算法 */

static int destroy_postorder_recursion(struct bitree_node_t *root)
{
    if (root)
    {
        /* 销毁左子树 */
        if (root->lchild)
        {
            destroy_postorder_recursion(root->lchild);
        }

        /* 销毁右子树 */
        if (root->rchild)
        {
            destroy_postorder_recursion(root->rchild);
        }

        /* 销毁自身 */
        if (root->data)
        {
            free(root->data);
            root->data = NULL;
        }
        free(root);
    }

    return 0;
}

/* 将树T清为空树 */

int ClearBiTree(struct bitree_t *tree)
{
    if (tree && tree->root)
    {
        destroy_postorder_recursion(tree->root);
        tree->root = NULL;
        tree->count = 0;
    }

    return 0;
}

/* 销毁树 */

int DestroyBiTree(struct bitree_t **ptree)
{
    struct bitree_t *tree = NULL;

    if (ptree)
    {
        tree = *ptree;
        if (tree)
        {
            ClearBiTree(tree);
            free(tree);
            *ptree = NULL;
        }
    }

    return 0;
}

/* 判断树是否为空树 */

int BiTreeEmpty(struct bitree_t *tree)
{
    return tree ? (tree->count == 0) : 1;
}

/* 计算深度 - 后根遍历 - 递归算法 */

static int depth_postorder_recursion(struct bitree_node_t *root)
{
    int depth = 0;
    int d2 = 0;

    if (root)
    {
        if (root->lchild)
        {
            depth = depth_postorder_recursion(root->lchild);
        }

        if (root->rchild)
        {
            d2 = depth_postorder_recursion(root->rchild);
        }

        if (depth < d2)
        {
            depth = d2;
        }

        /* 最后加上根节点本身一层 */
        return depth + 1;
    }

    return 0;
}

/* 返回树的深度 */

int BiTreeDepth(struct bitree_t *tree)
{
    if (tree)
    {
        return depth_postorder_recursion(tree->root);
    }

    return 0;
}

/* 返回树的根 */

struct bitree_node_t *BiTreeRoot(struct bitree_t *tree)
{
    if (tree)
    {
        return tree->root;
    }

    return NULL;
}

/* 若cur_e为非根结点，返回它的双亲，否则返回空 */

struct bitree_node_t *BiTreeParent(struct bitree_t *tree, struct bitree_node_t *node)
{
    if (node && node != tree->root)
    {
        return node->parent;
    }

    return NULL;
}

/* 若cur_e为非叶子结点，返回它的左孩子，否则返回空 */

struct bitree_node_t *BiTreeLeftChild(struct bitree_node_t *node)
{
    if (node && node->lchild)
    {
        return node->lchild;
    }

    return NULL;
}

/* 若cur_e为非叶子结点，返回它的右孩子，否则返回空 */

struct bitree_node_t *BiTreeRightChild(struct bitree_node_t *node)
{
    if (node && node->rchild)
    {
        return node->rchild;
    }

    return NULL;
}

/* 若cur_e有左兄弟，返回它的左兄弟，否则返回空 */

struct bitree_node_t *BiTreeLeftSibling(struct bitree_node_t *node)
{
    if (node && node->parent && node->parent->lchild)
    {
        if (node != node->parent->lchild)
        {
            return node->parent->lchild;
        }
    }

    return NULL;
}

/* 若cur_e有右兄弟，返回它的右兄弟，否则返回空 */

struct bitree_node_t *BiTreeRightSibling(struct bitree_node_t *node)
{
    if (node && node->parent && node->parent->rchild)
    {
        if (node != node->parent->rchild)
        {
            return node->parent->rchild;
        }
    }

    return NULL;
}