leetcode—树(easy) 3/5

1.二叉树的直径

给定一颗二叉树，计算它的直径长度。一棵二叉树的直径长度是任意两个节点路径长度中的最大值。这条路径可能穿过根节点。

思路：=>每个节点的左右子树的高度和的最大值。

class Solution {
private:
    int len = 0;
public:
    int maxLen(TreeNode* root)
    {
        if(root == nullptr)
        {
            return 0;
        }
        int l_len = maxLen(root -> left);
        int r_len = maxLen(root -> right);
        if(len < l_len + r_len)
        {
            len = l_len + r_len;
        }
        return max(l_len, r_len) + 1;
    }
    int diameterOfBinaryTree(TreeNode* root) {
        maxLen(root);
        return len;
    }
};

2.二叉树的坡度

给定一个二叉树，计算整个树的坡度。一个树的节点的坡度定义为，该节点左子树的节点之和和右子树节点之和的差的绝对值。空节点的坡度是0。整个树的坡度就是其所有节点的坡度之和。

思路：先求每个节点的坡度之后累加。

class Solution {
private:
    long sum = 0;
public:
    int add_up(TreeNode* root)
    {
        if(root == nullptr)
        {
            return 0;
        }
        int left_sum = add_up(root -> left);
        int right_sum = add_up(root -> right);
        sum += abs(left_sum - right_sum);
        return root -> val + left_sum + right_sum;
    }
    int findTilt(TreeNode* root) {
        add_up(root);
        return sum;
    }
};

3.另一个树的子树

给定两个非空二叉树s和t，检验s中是否包含和t具有相同结构和节点的子树。

bool isSame(TreeNode* s, TreeNode* t)
    {
        if(s == nullptr && t == nullptr)
        {
            return true;
        }
        else if(s == nullptr || t == nullptr)
        {
            return false;
        }
        if(s -> val != t -> val)
        {
            return false;
        }
        return isSame(s -> left, t -> left) && isSame(s -> right, t -> right);
    }
    bool isSubtree(TreeNode* s, TreeNode* t) {
        if(s == nullptr && t == nullptr)
        {
            return true;
        }
        else if(s == nullptr || t == nullptr)
        {
            return false;
        }
        if(s -> val == t -> val && isSame(s, t))
        {
            return true;
        }
        return isSubtree(s -> left, t) || isSubtree(s -> right, t);
    }

4. 根据二叉树创建字符串

采用前序遍历的方式，将一个二叉树转换成一个括号和数字组成的字符串。空节点则用一对空括号表示。

思路：当某个节点左右两个子节点均不为空的时候，应加上（），并在其中加入子节点的值。当一个节点只存在左节点时，可以省略右节点的（）。

string tree2str(TreeNode* t) {
        string str;
        if(t == nullptr)
        {
            return str;
        }
        str += to_string(t -> val);
        if(t -> left != nullptr)
        {
            str += "(" + tree2str(t -> left) + ")";
        }
        else if(t -> right != nullptr)
        {
            str += "()";
        }
        
        if(t -> right != nullptr)
        {
            str += "(" + tree2str(t -> right) + ")";
        }
        
        return str;
    }

5.合并二叉树

给定两个二叉树，当把他们中的一个覆盖到另一个上时，两个二叉树的一些节点会重叠。将他们合并为一个新的二叉树。如果两个节点重叠，那么他们的值相加作为节点合并后的新值，否则不为null的节点直接作为新二叉树的节点。

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {    //将t2合并到t1中
        if(t1 == nullptr)
        {
            return t2;
        }
        else if(t2 != nullptr)
        {
            t1 -> val += t2 -> val;
        }
                
        if(t1 -> left != nullptr && t2 != nullptr)
        {
            mergeTrees(t1 -> left, t2 -> left);
        }
        else if(t2 != nullptr)
        {
            t1 -> left = t2 -> left;
        }
        
        if(t1 -> right != nullptr && t2 != nullptr)
        {
            mergeTrees(t1 -> right, t2 -> right);
        }
        else if(t2 != nullptr)
        {
            t1 -> right = t2 -> right;
        }
        
        return t1;
    }

6.二叉树的层平均值

给定一个非空二叉树，返回一个由每层节点平均值组成的数组。

思路：队列实现层次遍历

7.两数之和IV—输入BST

给定一个二叉搜索树和一个目标结果，如果BST中存在两个元素且它们的和等于给定的目标结果，则返回true。

思路：前序遍历二叉树并用set存储