力扣题解：将二叉树变平衡

传送门
题目描述

代码实现
方法一

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int>Treeval;
    void SortTree(TreeNode* node)
    {
        //保证从小到大的顺序加入容器
        if(node->left!=NULL)
            SortTree(node->left);
        Treeval.push_back(node->val);
        if(node->right!=NULL)
            SortTree(node->right);
    }
    TreeNode* built(int left,int right)
    {
        int mid = (left + right) >> 1;//取中间值
        TreeNode* Root = new TreeNode(Treeval[mid]);//将中间值作为根节点建立平衡二叉树
        if(left < mid)
            Root->left = built(left,mid - 1);
        if(right > mid)
            Root->right = built(mid + 1,right);
        return Root;
    }
    TreeNode* balanceBST(TreeNode* root) {
        SortTree(root);//将二叉搜索树的关键值排序
        return built(0,Treeval.size()-1);//建立一个平衡二叉树
    }
};

方法二

struct AVLTreeNode{
    int val,height;
    AVLTreeNode* left,*right;
    AVLTreeNode(int x) : val(x),left(NULL),right(NULL),height(0) {}
} ;

//获取节点高度
int GetHeight(AVLTreeNode* root)
{
    return root == NULL?-1:root->height;
}
//左单旋转
AVLTreeNode* SingleRotateWithLeft(AVLTreeNode* k2)
{
    AVLTreeNode* k1;
    k1=k2->left;
    k2->left=k1->right;
    k1->right=k2;
    k2->height=max(GetHeight(k2->left),GetHeight(k2->right))+1;
    k1->height=max(GetHeight(k1->left),k2->height)+1;
    return k1;
}
//右单旋转
AVLTreeNode* SingleRotateWithRight(AVLTreeNode* k2)
{
    AVLTreeNode* k1;
    k1=k2->right;
    k2->right=k1->left;
    k1->left=k2;
    k2->height=max(GetHeight(k2->left),GetHeight(k2->right))+1;
    k1->height=max(GetHeight(k1->left),k2->height)+1;
    return k1;
}

//左双旋转
AVLTreeNode* DoubleRotateWithLeft(AVLTreeNode* k3)
{
    k3->left=SingleRotateWithRight(k3->left);
    return SingleRotateWithLeft(k3);
}
//右双旋转
AVLTreeNode* DoubleRotateWithRight(AVLTreeNode* k1)
{
    k1->right=SingleRotateWithLeft(k1->right);
    return SingleRotateWithRight(k1);
}
//平衡二叉树的插入
AVLTreeNode* InsertAVLtree(int x,AVLTreeNode* T)
{
    if(T == NULL)
        T = new AVLTreeNode(x);
    else if(x < T->val)
    {
        T->left=InsertAVLtree(x,T->left);
        if(GetHeight(T->left)-GetHeight(T->right)==2)
        {
            if(x < T->left->val)//判断d单旋还是双旋
                T = SingleRotateWithLeft(T);
            else
                T = DoubleRotateWithLeft(T);
        }
    }
    else if(x > T->val)
    {
        T->right=InsertAVLtree(x,T->right);
        if(GetHeight(T->right)-GetHeight(T->left)==2)
        {
            if(x > T->right->val)
                T = SingleRotateWithRight(T);
            else
                T = DoubleRotateWithRight(T);
        }
    }
    T->height = max(GetHeight(T->left),GetHeight(T->right))+1;
    return T;
}

AVLTreeNode* AVLtree = nullptr;//定义一个平衡二叉树

void dfs(TreeNode* Root)//中序遍历
{
    if(!Root)
        return;
    AVLtree = InsertAVLtree(Root->val,AVLtree);//将二叉树的所有元素重新插入到平衡二叉树中
    if(Root->left != NULL)
        dfs(Root->left);
    if(Root->right != NULL)
        dfs(Root->right);
}
void build(AVLTreeNode* Troot, TreeNode*& root)
{
	if (Troot == NULL) 
        return;
	root = new TreeNode(Troot->val);
	build(Troot->left, root->left);
	build(Troot->right, root->right);
}
class Solution {
public:
    TreeNode* balanceBST(TreeNode* root) {
        AVLtree = nullptr;
        dfs(root);
        TreeNode* ret = nullptr;
        build(AVLtree, ret);
        return ret;
    }
};