AVL树

树节点定义：

typedef struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int a):val(a), left(NULL), right(NULL){}
}TreeNode;

 

AVL树接口：

class AvlTree{
private:
    TreeNode *root;

    //获取子树深度
    int getHeight(TreeNode *node){
        if(node == NULL){
            return 0;
        }
        int left = getHeight(node->left);
        int right = getHeight(node->right);
        return (left > right ? left :right) + 1;
    }

    //获取子树平衡因子
    int getBalanceFactor(TreeNode *node){
        if(node == NULL){
            return 0;
        }
        return getHeight(node->left) - getHeight(node->right);
    }

    //判断子树是否平衡
    bool isBalanced(TreeNode *node){
        if(node == NULL){
            return true;
        }
        int balanceFactor = getBalanceFactor(node);
        if(balanceFactor > 1 || balanceFactor <-1){
            return false;
        }
        return isBalanced(node->left) && isBalanced(node->right);
    }

    //左旋
    TreeNode* leftRotate(TreeNode *node){
        if(node->right == NULL){
            return NULL;
        }
        TreeNode *newRoot = node->right;
        node->right = newRoot->left;
        newRoot->left = node;
        return newRoot;
    }

    //右旋
    TreeNode* rightRotate(TreeNode *node){
        if(node->left == NULL){
            return NULL;
        }
        TreeNode *newRoot = node->left;
        node->left = newRoot->right;
        newRoot->right = node;
        return newRoot;
    }

    //平衡指定子树
    TreeNode* balanceNode(TreeNode *node){
        int balanceFactor = getBalanceFactor(node);
        if(balanceFactor > 1 && getBalanceFactor(node->left) > 0){
            node = rightRotate(node);
        } 
        if(balanceFactor < -1 && getBalanceFactor(node->right) < 0){
            node = leftRotate(node);
        }
        if(balanceFactor > 1 && getBalanceFactor(node->right) < 0){
            node->left = leftRotate(node->left);
            node = rightRotate(node);
        }
        if(balanceFactor < -1 && getBalanceFactor(node->right) > 0){
            node->right = rightRotate(node->right);
            node = leftRotate(node);
        }

        return node;
    }

    //后继节点
    TreeNode* successor(TreeNode *node){
        if(node == NULL || node->right == NULL)
        {
            return NULL;
        }
        node = node->right;
        while(node->left != NULL){
            node = node->left;
        }
        return node;
    }

    //前置节点
    TreeNode* predessor(TreeNode *node){
        if(node == NULL || node->left == NULL)
        {
            return NULL;
        }
        node = node->left;
        while(node->right != NULL){
            node = node->right;
        }
        return node;
    }

    //子树查找特定节点
    TreeNode* findNode(TreeNode* node, int value){
        if(node == NULL || node->val == value){
            return node;
        }
        if(value <= node->val){
            return findNode(node->left, value);
        }else{
            return findNode(node->right, value);
        }
    }

    //子树添加节点
    TreeNode* addnode(TreeNode *node, int value){
        if(node == NULL){
            return new TreeNode(value);
        }
        if(value < node->val){
            node->left = addnode(node->left, value);
        }else if(value > node->val){
            node->right = addnode(node->right, value);
        }
        /* 平衡 */
        node = balanceNode(node);

        return node;
    }

    //子树删除节点
    TreeNode* deletenode(TreeNode *node, int value){
        if(node == NULL){
            return NULL;
        }
        if(value < node->val){
            node->left = deletenode(node->left, value);
        }else if(value > node->val){
            node->right = deletenode(node->right, value);
        }else{  //value==node->val
            if(node->right != NULL){
                node->val = successor(node)->val;
                node->right = deletenode(node->right, node->val);
            }else if(node->left != NULL){
                node->val = predessor(node)->val;
                node->left = deletenode(node->left, node->val);
            }else{
                delete node;
                node = NULL;
            }
        }
        node = balanceNode(node);
        return node;
    }

    //打印节点下的所有节点
    void dumpNode(TreeNode *node){
        if(node == NULL){
            return;
        }
        queue<TreeNode*> q;
        q.push(node);
        while(!q.empty()){
            int n = q.size();
            for(int i = 0; i < n; i++){
                TreeNode *tmp = q.front();
                q.pop();
                printf("%d ", tmp->val);
                if(tmp->left){
                    q.push(tmp->left);
                }
                if(tmp->right){
                    q.push(tmp->right);
                }
            }
            printf("\n");
        }

    }

public:
    AvlTree(){
        root = NULL;
    }
    AvlTree(int a){
        root = new TreeNode(a);
    }

    void add(int value){
        root =  addnode(this->root, value);
        return;
    }

    void remove(int value){
        root =  deletenode(this->root, value);
        return;
    }

    bool find(int value){
        TreeNode *ret = findNode(root, value);
        return ret != NULL;
    }

    void dumpTree(void)
    {
        dumpNode(this->root);
    }
};