avl 平衡二叉树

实现平衡二叉树

参考博客：http://blog.csdn.net/whucyl/article/details/17289841

参考博客：http://www.cnblogs.com/QG-whz/p/5167238.html

个人实现代码：

#include 
#include 
#include 

using namespace std;
struct BinaryTreeNode{
    int key;
    int height;
    BinaryTreeNode *left;
    BinaryTreeNode *right;
};
typedef BinaryTreeNode avlNode;

typedef BinaryTreeNode avlTree;
template 
T maxh(T ha,T hb) {
    return ha > hb ? ha : hb;
}
int height(avlTree * tree) {
    if(NULL == tree) return 0;
    return tree->height;
}
avlNode* singleRightRotate(avlNode *aNode) {
    avlNode* bNode = aNode->left;
    aNode->left = bNode->right;
    bNode->right = aNode;
    aNode->height = maxh(height(aNode->right),height(aNode->left)) + 1;
    bNode->height = maxh(height(bNode->right),height(bNode->left)) + 1;
    return bNode;
}

avlNode* singleLeftRotate(avlNode *aNode) {
    avlNode* bNode = aNode->right;
    aNode->right = bNode->left;
    bNode->left = aNode;
    aNode->height = maxh(height(aNode->right),height(aNode->left)) + 1;
    bNode->height = maxh(height(bNode->right),height(bNode->left)) + 1;
    return bNode;
}

avlNode* leftRightRotate(avlNode* aNode) {
    aNode->left = singleLeftRotate(aNode->left);
    return singleRightRotate(aNode);
}

avlNode* rightLeftRotate(avlNode* aNode) {
    aNode->right = singleRightRotate(aNode->right);
    return singleLeftRotate(aNode);
}
avlNode* avl_insert(avlTree* &tree,int key) {
    if(tree == NULL) {
        tree = (avlNode*)malloc(sizeof(avlNode));
        tree->key = key;
        tree->height = 1;
        tree->left = tree->right = NULL;
    } else if (key > tree->key) {
        tree->right = avl_insert(tree->right,key);
        int balanceFactor = height(tree->right) - height(tree->left);
        if (2 == balanceFactor) {
            if (key > tree->right->key) {
                tree = singleLeftRotate(tree);
            } else {
                tree = rightLeftRotate(tree);
            }
        }
    } else if (key < tree->key) {
        tree->left = avl_insert(tree->left,key);
        int balanceFactor = height(tree->left) - height(tree->right);
        if (2 == balanceFactor) {
            if (key < tree->left->key) {
                tree = singleRightRotate(tree);
            } else {
                tree = leftRightRotate(tree);
            }
        }
    }
    tree->height=maxh(height(tree->left),height(tree->right)) + 1;
    return tree;
}

avlNode* avl_delete(avlTree* &tree,int key) {
    if(NULL == tree) {
        return NULL;
    }
    if(key > tree->key) {
        tree->right = avl_delete(tree->right,key);
    } else if (key < tree->key) {
        tree->left = avl_delete(tree->left,key);
    } else {
        if(NULL != tree->left) {
            avlNode* dn = NULL;
            for(dn = tree->left;NULL != dn->right;dn = dn->right){
            }
            tree->key = dn->key;
            tree->left = avl_delete(tree->left,dn->key);
        } else if(NULL != tree->right){
            avlNode* dn = NULL;
            for(dn = tree->right;NULL != dn->left;dn = dn->left){
            }
            tree->key = dn->key;
            tree->right = avl_delete(tree->right,dn->key);
        } else {
            free(tree);
            return NULL;
        }
    }
    if (height(tree->left) - height(tree->right) == 2) {
        if (height(tree->left->right) - height(tree->left->left) == 1) {
            tree = leftRightRotate(tree);
        } else {
            tree = singleRightRotate(tree);
        }
    } else if (height(tree->left) - height(tree->right) == -2) {
        if (height(tree->right->left) - height(tree->right->right) == 1) {
            tree = rightLeftRotate(tree);
        } else {
            tree = singleLeftRotate(tree);
        }
    }
    tree->height = maxh(height(tree->left),height(tree->right)) + 1;
    return tree;
}
//先序遍历
void preOrder(avlTree* &tree) {
    if(tree != NULL) {
        printf("%d ",tree->key);
        preOrder(tree->left);
        preOrder(tree->right);
    }
}

void inOrder(avlTree* &tree) {
    if(tree != NULL) {
        inOrder(tree->left);
        printf("%d ",tree->key);
        inOrder(tree->right);
    }
}

void lastOrder(avlTree* &tree) {
    if(tree != NULL) {
        lastOrder(tree->left);
        lastOrder(tree->right);
        printf("%d ",tree->key);
    }
}

void destory(avlTree* &tree) {
    if(tree != NULL) {
        destory(tree->left);
        destory(tree->right);
        free(tree);
        tree->left = tree->right = NULL;
        tree = NULL;
    }
}
int main()
{
    int value,choice/**选择；0，插入；1，删除，2前序遍历；3，中序遍历，4，后序遍历*/;
    avlTree *tree = NULL;// = (avlTree*) malloc(sizeof(avlTree));
    printf("选择；0，插入；1，删除，2前序遍历；3，中序遍历，4，后序遍历\n");
    while(~scanf("%d",&choice)) {
        switch (choice){
            case 0: {
                scanf("%d",&value);
                avl_insert(tree,value);
                break;
            }
            case 1: {
                scanf("%d",&value);
                avl_delete(tree,value);
                break;
            }
            case 2: {
                preOrder(tree);
                printf("\n");
                break;
            }
            case 3: {
                inOrder(tree);
                printf("\n");
                break;
            }
            case 4: {
                lastOrder(tree);
                printf("\n");
                break;
            } default :{
                destory(tree);
                break;
            }
            printf("选择；0，插入；1，删除，2前序遍历；3，中序遍历，4，后序遍历\n");
        }
    }
    return 0;
}
#include 
#include 

using namespace std;
struct BinaryTreeNode{
    int key;
    int height;
    BinaryTreeNode *left;
    BinaryTreeNode *right;
};
typedef BinaryTreeNode avlNode;

typedef BinaryTreeNode avlTree;
template 
T maxh(T ha,T hb) {
    return ha > hb ? ha : hb;
}
int height(avlTree * tree) {
    if(NULL == tree) return 0;
    return tree->height;
}
avlNode* singleRightRotate(avlNode *aNode) {
    avlNode* bNode = aNode->left;
    aNode->left = bNode->right;
    bNode->right = aNode;
    aNode->height = maxh(height(aNode->right),height(aNode->left)) + 1;
    bNode->height = maxh(height(bNode->right),height(bNode->left)) + 1;
    return bNode;
}

avlNode* singleLeftRotate(avlNode *aNode) {
    avlNode* bNode = aNode->right;
    aNode->right = bNode->left;
    bNode->left = aNode;
    aNode->height = maxh(height(aNode->right),height(aNode->left)) + 1;
    bNode->height = maxh(height(bNode->right),height(bNode->left)) + 1;
    return bNode;
}

avlNode* leftRightRotate(avlNode* aNode) {
    aNode->left = singleLeftRotate(aNode->left);
    return singleRightRotate(aNode);
}

avlNode* rightLeftRotate(avlNode* aNode) {
    aNode->right = singleRightRotate(aNode->right);
    return singleLeftRotate(aNode);
}
avlNode* avl_insert(avlTree* &tree,int key) {
    if(tree == NULL) {
        tree = (avlNode*)malloc(sizeof(avlNode));
        tree->key = key;
        tree->height = 1;
        tree->left = tree->right = NULL;
    } else if (key > tree->key) {
        tree->right = avl_insert(tree->right,key);
        int balanceFactor = height(tree->right) - height(tree->left);
        if (2 == balanceFactor) {
            if (key > tree->right->key) {
                tree = singleLeftRotate(tree);
            } else {
                tree = rightLeftRotate(tree);
            }
        }
    } else if (key < tree->key) {
        tree->left = avl_insert(tree->left,key);
        int balanceFactor = height(tree->left) - height(tree->right);
        if (2 == balanceFactor) {
            if (key < tree->left->key) {
                tree = singleRightRotate(tree);
            } else {
                tree = leftRightRotate(tree);
            }
        }
    }
    tree->height=maxh(height(tree->left),height(tree->right)) + 1;
    return tree;
}

avlNode* avl_delete(avlTree* &tree,int key) {
    if(NULL == tree) {
        return NULL;
    }
    if(key > tree->key) {
        tree->right = avl_delete(tree->right,key);
    } else if (key < tree->key) {
        tree->left = avl_delete(tree->left,key);
    } else {
        if(NULL != tree->left) {
            avlNode* dn = NULL;
            for(dn = tree->left;NULL != dn->right;dn = dn->right){
            }
            tree->key = dn->key;
            tree->left = avl_delete(tree->left,dn->key);
        } else if(NULL != tree->right){
            avlNode* dn = NULL;
            for(dn = tree->right;NULL != dn->left;dn = dn->left){
            }
            tree->key = dn->key;
            tree->right = avl_delete(tree->right,dn->key);
        } else {
            free(tree);
            return NULL;
        }
    }
    if (height(tree->left) - height(tree->right) == 2) {
        if (height(tree->left->right) - height(tree->left->left) == 1) {
            tree = leftRightRotate(tree);
        } else {
            tree = singleRightRotate(tree);
        }
    } else if (height(tree->left) - height(tree->right) == -2) {
        if (height(tree->right->left) - height(tree->right->right) == 1) {
            tree = rightLeftRotate(tree);
        } else {
            tree = singleLeftRotate(tree);
        }
    }
    tree->height = maxh(height(tree->left),height(tree->right)) + 1;
    return tree;
}
//先序遍历
void preOrder(avlTree* &tree) {
    if(tree != NULL) {
        printf("%d ",tree->key);
        preOrder(tree->left);
        preOrder(tree->right);
    }
}

void inOrder(avlTree* &tree) {
    if(tree != NULL) {
        inOrder(tree->left);
        printf("%d ",tree->key);
        inOrder(tree->right);
    }
}

void lastOrder(avlTree* &tree) {
    if(tree != NULL) {
        lastOrder(tree->left);
        lastOrder(tree->right);
        printf("%d ",tree->key);
    }
}

void destory(avlTree* &tree) {
    if(tree != NULL) {
        destory(tree->left);
        destory(tree->right);
        free(tree);
        tree->left = tree->right = NULL;
        tree = NULL;
    }
}
int main()
{
    int value,choice/**选择；0，插入；1，删除，2前序遍历；3，中序遍历，4，后序遍历*/;
    avlTree *tree = NULL;// = (avlTree*) malloc(sizeof(avlTree));
    printf("选择；0，插入；1，删除，2前序遍历；3，中序遍历，4，后序遍历\n");
    while(~scanf("%d",&choice)) {
        switch (choice){
            case 0: {
                scanf("%d",&value);
                avl_insert(tree,value);
                break;
            }
            case 1: {
                scanf("%d",&value);
                avl_delete(tree,value);
                break;
            }
            case 2: {
                preOrder(tree);
                printf("\n");
                break;
            }
            case 3: {
                inOrder(tree);
                printf("\n");
                break;
            }
            case 4: {
                lastOrder(tree);
                printf("\n");
                break;
            } default :{
                destory(tree);
                break;
            }
            printf("选择；0，插入；1，删除，2前序遍历；3，中序遍历，4，后序遍历\n");
        }
    }
    return 0;
}