Tree Problems

Balanced Binary Tree

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

//思路1：遍历每个节点的左右孩子是否平衡，否，ans为false
//缺点：每个节点的左右孩子求深度存在大量重复操作
 int depth(TreeNode* root) {
        if (root == NULL)
            return 0;
        return max(depth(root->left)+1, depth(root->right)+1);
    }
    void dfs(TreeNode* root, bool &ans) {    //先序遍历每个节点
        if (root == NULL)
            return;
        if (abs(depth(root->left) - depth(root->right)) > 1)
            ans = false;
        dfs(root -> left, ans);
        dfs(root -> right, ans);
    }
    bool isBalanced(TreeNode* root) {
        bool res = true;
        dfs(root, res);
        return res;
    }
//思路2：哈希表存储每个遍历过孩子节点的深度
//       1.遍历root，存储每个节点的深度，注意：空指针一定要存为0
//       2.再次遍历root，判断是否平衡
//缺点：代码臃肿
class Solution {
public:
    unordered_map<TreeNode*, int> um;
    int depth(TreeNode* root) {
        if (root == NULL)
            return 0;
        int res = max(depth(root->left)+1, depth(root->right)+1);
        um[root] = res;
        return res;
    }
    void dfs(TreeNode* root, bool &ans) {
        if (root == NULL)
            return;
        if (abs(um[root->left] - um[root->right]) > 1)
            ans = false;
        dfs(root -> left, ans);
        dfs(root -> right, ans);
    }
    bool isBalanced(TreeNode* root) {
        bool res = true;
        um[NULL] = 0;    //！！！
        depth(root);
        dfs(root, res);

        return res;
    }
};
//思路三：利用返回值
//优点：和思路2一样快，代码简洁
 int depth(TreeNode* root, bool & ans) {
        if (root == NULL)
            return 0;
        int l = depth(root -> left, ans);
        int r = depth(root -> right, ans);
        if (abs(l-r)>1)
            ans = false;
        return max(l+1,r+1);
    }

    bool isBalanced(TreeNode* root) {
        bool ans = true;
        depth(root, ans);
        return ans;
    }

    //如果不需要遍历完，可添加控制conti，注意递归函数应为void。
    //非conti 的时候直接返回，conti才继续递归过程

二叉搜索树序列化

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
／／思路一：把每个节点按顺序存储，再连接
//中序遍历存储每个节点
//顺序连接节点
    void Rcs(TreeNode* root, vector<TreeNode*> &v)
    {
        if(root == NULL)
            return ;
        Rcs(root->left,v);
        v.push_back(root);//注意一定是中序遍历
        Rcs(root->right,v);
    }


    TreeNode* Convert(TreeNode* pRoot)
    {
        if(pRoot == NULL)
            return pRoot;
        vector<TreeNode*> v;
        Rcs(pRoot,v);
        for(int i = 0; i < v.size()-1; i++)
        {
            v[i]->right = v[i+1];//注意方向不要写错
            v[i+1]->left = v[i];
        }

        v.back()->right = NULL;
        return v[0];
    }
／／思路二：每两个节点进行连接
//中序遍历每个节点
// 设置pre ，cur 的 pre 为左孩子，cur 右孩子的pre 为 cur
// 最前节点的pre为null
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if(pRootOfTree == nullptr) return nullptr;
        TreeNode* pre = nullptr;

        convertHelper(pRootOfTree, pre);

        TreeNode* res = pRootOfTree;
        while(res ->left)
            res = res ->left;
        return res;
    }

    void convertHelper(TreeNode* cur, TreeNode*& pre)
    {
        if(cur == nullptr) return;

        convertHelper(cur ->left, pre);

        cur ->left = pre;
        if(pre) pre ->right = cur;
        pre = cur;

        convertHelper(cur ->right, pre);
     }     

对称的二叉树

   //思路1：把二叉树中序遍历存储，对称的二叉树中序遍历也应该完全对称
   //判断最始和最末的节点值及其孩子节点是否相同
   //不判断孩子会出现5,5,5,5,#,#,5,5,#,5 的用例错误

    void rcs(TreeNode* root, vector<TreeNode*> &v)
    {
        if(root == NULL)
            return;
        rcs(root->left,v);
        v.push_back(root);
        rcs(root->right,v);
    }
    bool isSymmetrical(TreeNode* pRoot)
    {
        vector<TreeNode*> v;
        rcs(pRoot,v);
        for(int i = 0, j = v.size()-1; i < j; i++,j--)
        {
            if(v[i]->val != v[j]->val)
                return false;
            if(v[i]->left)
            {
                if(!v[j]->right || v[i]->left->val != v[j]->right->val)
                    return false;
            }
            if(v[i]->right)
            {
                if(!v[j]->left || v[i]->right->val != v[j]->left->val)
                    return false;
            }
        }
        return true;
    }
//思路2：利用返回值实现的递归
    bool helper(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot1 == NULL && pRoot2 == NULL)
            return true;
        if(pRoot1 ==NULL || pRoot2 == NULL)
            return false;
        if(pRoot1->val != pRoot2->val)
            return false;

        return helper(pRoot1->left,pRoot2->right)&&helper(pRoot1->right,pRoot2->left);
    }

    bool isSymmetrical(TreeNode* pRoot)
    {
        if(!pRoot)
            return true;
        return helper(pRoot,pRoot);

    }