數據結構與算法4：二叉樹2（平衡二叉樹）

代碼轉自：http://www.cnblogs.com/skywang12345/p/3576969.html，圖文並茂，此處只用於個人備份，感謝原作者skywang12345

avl_tree.h：

#ifndef _AVL_TREE_H_
#define _AVL_TREE_H_

typedef int Type;

typedef struct AVLTreeNode{
    Type key;                    // 關鍵字(鍵值)
    int height;
    struct AVLTreeNode *left;    // 左孩子
    struct AVLTreeNode *right;    // 右孩子
}Node, *AVLTree;

// 獲取AVL樹的高度
int avltree_height(AVLTree tree);

// 前序遍歷"AVL樹"
void preorder_avltree(AVLTree tree);
// 中序遍歷"AVL樹"
void inorder_avltree(AVLTree tree);
// 後序遍歷"AVL樹"
void postorder_avltree(AVLTree tree);

void print_avltree(AVLTree tree, Type key, int direction);

// (遞歸實現)查找"AVL樹x"中鍵值爲key的節點
Node* avltree_search(AVLTree x, Type key);
// (非遞歸實現)查找"AVL樹x"中鍵值爲key的節點
Node* iterative_avltree_search(AVLTree x, Type key);

// 查找最小結點：返回tree爲根結點的AVL樹的最小結點。
Node* avltree_minimum(AVLTree tree);
// 查找最大結點：返回tree爲根結點的AVL樹的最大結點。
Node* avltree_maximum(AVLTree tree);

// 將結點插入到AVL樹中，返回根節點
Node* avltree_insert(AVLTree tree, Type key);

// 刪除結點(key是節點值)，返回根節點
Node* avltree_delete(AVLTree tree, Type key);

// 銷燬AVL樹
void destroy_avltree(AVLTree tree);


#endif

avl_tree.c：

/**
 * AVL樹(C語言): C語言實現的AVL樹。
 *
 * @author skywang
 * @date 2013/11/07
 */

#include <stdio.h>
#include <stdlib.h>
#include "avltree.h"

#define HEIGHT(p)    ( (p==NULL) ? -1 : (((Node *)(p))->height) )
#define MAX(a, b)    ( (a) > (b) ? (a) : (b) )

/*
 * 獲取AVL樹的高度
 */
int avltree_height(AVLTree tree)
{
    return HEIGHT(tree);
}

/*
 * 前序遍歷"AVL樹"
 */
void preorder_avltree(AVLTree tree)
{
    if(tree != NULL)
    {
        printf("%d ", tree->key);
        preorder_avltree(tree->left);
        preorder_avltree(tree->right);
    }
}


/*
 * 中序遍歷"AVL樹"
 */
void inorder_avltree(AVLTree tree)
{
    if(tree != NULL)
    {
        inorder_avltree(tree->left);
        printf("%d ", tree->key);
        inorder_avltree(tree->right);
    }
}

/*
 * 後序遍歷"AVL樹"
 */
void postorder_avltree(AVLTree tree)
{
    if(tree != NULL)
    {
        postorder_avltree(tree->left);
        postorder_avltree(tree->right);
        printf("%d ", tree->key);
    }
}

/*
 * (遞歸實現)查找"AVL樹x"中鍵值爲key的節點
 */
Node* avltree_search(AVLTree x, Type key)
{
    if (x==NULL || x->key==key)
        return x;

    if (key < x->key)
        return avltree_search(x->left, key);
    else
        return avltree_search(x->right, key);
}

/*
 * (非遞歸實現)查找"AVL樹x"中鍵值爲key的節點
 */
Node* iterative_avltree_search(AVLTree x, Type key)
{
    while ((x!=NULL) && (x->key!=key))
    {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }

    return x;
}

/* 
 * 查找最小結點：返回tree爲根結點的AVL樹的最小結點。
 */
Node* avltree_minimum(AVLTree tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->left != NULL)
        tree = tree->left;
    return tree;
}
 
/* 
 * 查找最大結點：返回tree爲根結點的AVL樹的最大結點。
 */
Node* avltree_maximum(AVLTree tree)
{
    if (tree == NULL)
        return NULL;

    while(tree->right != NULL)
        tree = tree->right;
    return tree;
}

/*
 * LL：左左對應的情況(左單旋轉)。
 *
 * 返回值：旋轉後的根節點
 */
static Node* left_left_rotation(AVLTree k2)
{
    AVLTree k1;

    k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;

    k2->height = MAX( HEIGHT(k2->left), HEIGHT(k2->right)) + 1;
    k1->height = MAX( HEIGHT(k1->left), k2->height) + 1;

    return k1;
}

/*
 * RR：右右對應的情況(右單旋轉)。
 *
 * 返回值：旋轉後的根節點
 */
static Node* right_right_rotation(AVLTree k1)
{
    AVLTree k2;

    k2 = k1->right;
    k1->right = k2->left;
    k2->left = k1;

    k1->height = MAX( HEIGHT(k1->left), HEIGHT(k1->right)) + 1;
    k2->height = MAX( HEIGHT(k2->right), k1->height) + 1;

    return k2;
}

/*
 * LR：左右對應的情況(左雙旋轉)。
 *
 * 返回值：旋轉後的根節點
 */
static Node* left_right_rotation(AVLTree k3)
{
    k3->left = right_right_rotation(k3->left);

    return left_left_rotation(k3);
}

/*
 * RL：右左對應的情況(右雙旋轉)。
 *
 * 返回值：旋轉後的根節點
 */
static Node* right_left_rotation(AVLTree k1)
{
    k1->right = left_left_rotation(k1->right);

    return right_right_rotation(k1);
}

/*
 * 創建AVL樹結點。
 *
 * 參數說明：
 *     key 是鍵值。
 *     left 是左孩子。
 *     right 是右孩子。
 */
static Node* avltree_create_node(Type key, Node *left, Node* right)
{
    Node* p;

    if ((p = (Node *)malloc(sizeof(Node))) == NULL)
        return NULL;
    p->key = key;
    p->height = 0;
    p->left = left;
    p->right = right;

    return p;
}

/* 
 * 將結點插入到AVL樹中，並返回根節點
 *
 * 參數說明：
 *     tree AVL樹的根結點
 *     key 插入的結點的鍵值
 * 返回值：
 *     根節點
 */
Node* avltree_insert(AVLTree tree, Type key)
{
    if (tree == NULL) 
    {
        // 新建節點
        tree = avltree_create_node(key, NULL, NULL);
        if (tree==NULL)
        {
            printf("ERROR: create avltree node failed!\n");
            return NULL;
        }
    }
    else if (key < tree->key) // 應該將key插入到"tree的左子樹"的情況
    {
        tree->left = avltree_insert(tree->left, key);
        // 插入節點後，若AVL樹失去平衡，則進行相應的調節。
        if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
        {
            if (key < tree->left->key)
                tree = left_left_rotation(tree);
            else
                tree = left_right_rotation(tree);
        }
    }
    else if (key > tree->key) // 應該將key插入到"tree的右子樹"的情況
    {
        tree->right = avltree_insert(tree->right, key);
        // 插入節點後，若AVL樹失去平衡，則進行相應的調節。
        if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
        {
            if (key > tree->right->key)
                tree = right_right_rotation(tree);
            else
                tree = right_left_rotation(tree);
        }
    }
    else //key == tree->key)
    {
        printf("添加失敗：不允許添加相同的節點！\n");
    }

    tree->height = MAX( HEIGHT(tree->left), HEIGHT(tree->right)) + 1;

    return tree;
}

/* 
 * 刪除結點(z)，返回根節點
 *
 * 參數說明：
 *     ptree AVL樹的根結點
 *     z 待刪除的結點
 * 返回值：
 *     根節點
 */
static Node* delete_node(AVLTree tree, Node *z)
{
    // 根爲空 或者 沒有要刪除的節點，直接返回NULL。
    if (tree==NULL || z==NULL)
        return NULL;

    if (z->key < tree->key)        // 待刪除的節點在"tree的左子樹"中
    {
        tree->left = delete_node(tree->left, z);
        // 刪除節點後，若AVL樹失去平衡，則進行相應的調節。
        if (HEIGHT(tree->right) - HEIGHT(tree->left) == 2)
        {
            Node *r =  tree->right;
            if (HEIGHT(r->left) > HEIGHT(r->right))
                tree = right_left_rotation(tree);
            else
                tree = right_right_rotation(tree);
        }
    }
    else if (z->key > tree->key)// 待刪除的節點在"tree的右子樹"中
    {
        tree->right = delete_node(tree->right, z);
        // 刪除節點後，若AVL樹失去平衡，則進行相應的調節。
        if (HEIGHT(tree->left) - HEIGHT(tree->right) == 2)
        {
            Node *l =  tree->left;
            if (HEIGHT(l->right) > HEIGHT(l->left))
                tree = left_right_rotation(tree);
            else
                tree = left_left_rotation(tree);
        }
    }
    else    // tree是對應要刪除的節點。
    {
        // tree的左右孩子都非空
        if ((tree->left) && (tree->right))
        {
            if (HEIGHT(tree->left) > HEIGHT(tree->right))
            {
                // 如果tree的左子樹比右子樹高；
                // 則(01)找出tree的左子樹中的最大節點
                //   (02)將該最大節點的值賦值給tree。
                //   (03)刪除該最大節點。
                // 這類似於用"tree的左子樹中最大節點"做"tree"的替身；
                // 採用這種方式的好處是：刪除"tree的左子樹中最大節點"之後，AVL樹仍然是平衡的。
                Node *max = avltree_maximum(tree->left);
                tree->key = max->key;
                tree->left = delete_node(tree->left, max);
            }
            else
            {
                // 如果tree的左子樹不比右子樹高(即它們相等，或右子樹比左子樹高1)
                // 則(01)找出tree的右子樹中的最小節點
                //   (02)將該最小節點的值賦值給tree。
                //   (03)刪除該最小節點。
                // 這類似於用"tree的右子樹中最小節點"做"tree"的替身；
                // 採用這種方式的好處是：刪除"tree的右子樹中最小節點"之後，AVL樹仍然是平衡的。
                Node *min = avltree_maximum(tree->right);
                tree->key = min->key;
                tree->right = delete_node(tree->right, min);
            }
        }
        else
        {
            Node *tmp = tree;
            tree = tree->left ? tree->left : tree->right;
            free(tmp);
        }
    }

    return tree;
}

/* 
 * 刪除結點(key是節點值)，返回根節點
 *
 * 參數說明：
 *     tree AVL樹的根結點
 *     key 待刪除的結點的鍵值
 * 返回值：
 *     根節點
 */
Node* avltree_delete(AVLTree tree, Type key)
{
    Node *z; 

    if ((z = avltree_search(tree, key)) != NULL)
        tree = delete_node(tree, z);
    return tree;
}

/* 
 * 銷燬AVL樹
 */
void destroy_avltree(AVLTree tree)
{
    if (tree==NULL)
        return ;

    if (tree->left != NULL)
        destroy_avltree(tree->left);
    if (tree->right != NULL)
        destroy_avltree(tree->right);

    free(tree);
}

/*
 * 打印"AVL樹"
 *
 * tree       -- AVL樹的節點
 * key        -- 節點的鍵值 
 * direction  --  0，表示該節點是根節點;
 *               -1，表示該節點是它的父結點的左孩子;
 *                1，表示該節點是它的父結點的右孩子。
 */
void print_avltree(AVLTree tree, Type key, int direction)
{
    if(tree != NULL)
    {
        if(direction==0)    // tree是根節點
            printf("%2d is root\n", tree->key, key);
        else                // tree是分支節點
            printf("%2d is %2d's %6s child\n", tree->key, key, direction==1?"right" : "left");

        print_avltree(tree->left, tree->key, -1);
        print_avltree(tree->right,tree->key,  1);
    }
}