leetcode200题之二叉树专题（一）

1. 二叉树的直径

一条路径的长度为该路径经过的节点数减一，所以求直径（即求路径长度的最大值）等效于求路径经过节点数的最大值减一。而任意一条路径均可以被看作由某个节点为起点，从其左儿子和右儿子向下遍历的路径拼接得到。

我们定义一个递归函数 depth(node) 计算d_node，函数返回该节点为根的子树的深度。先递归调用左儿子和右儿子求得它们为根的子树的深度 left 和 right ，则该节点为根的子树的深度即为 max(L,R)+1，该节点的 d_node值为 L+R+1。

class Solution {
public:
    int diameterOfBinaryTree(TreeNode* root) {
        int ans=1;
        depth(root,ans);
        return ans-1;
    }
    int depth(TreeNode* root, int& ans){
        if(root==nullptr) return 0;
        int left=depth(root->left,ans);
        int right=depth(root->right,ans);
        ans=max(ans, left+right+1);
        return left < right ? right+1 : left+1;
    }
};

2. 合并二叉树

递归解法：可以对这两棵树同时进行前序遍历，并将对应的节点进行合并。在遍历时，如果两棵树的当前节点均不为空，我们就将它们的值进行相加，并对它们的左孩子和右孩子进行递归合并；如果其中有一棵树为空，那么我们返回另一颗树作为结果；如果两棵树均为空，此时返回任意一棵树均可（因为都是空）。

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        t1->val += t2->val;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);
        return t1;
    }
};

迭代解法：层序遍历，将相应节点合并。

//迭代解法
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(t1==nullptr)  return t2;
        if(t2==nullptr)  return t1;
        queue<TreeNode*> q;
        q.push(t1);
        q.push(t2);
        while(!q.empty()){
            TreeNode* node1=q.front();  q.pop();
            TreeNode* node2=q.front();  q.pop();
            if(node1!=nullptr && node2!=nullptr){
                node1->val += node2->val;
            }
            if(node1->left!=nullptr && node2->left!=nullptr){
                q.push(node1->left);
                q.push(node2->left);
            }
            if(node1->right!=nullptr && node2->right!=nullptr){
                q.push(node1->right);
                q.push(node2->right);
            }
            if(node1->left==nullptr && node2->left!=nullptr){
                node1->left=node2->left;
            }
            if(node1->right==nullptr && node2->right!=nullptr){
                node1->right=node2->right;
            }
        }
        return t1;
    }
};

3. 树的子结构  

recur(A,B)函数：判断树 A中 以a为根节点的子树 是否包含树 B；

终止条件：
                       当节点 B为空：说明树 BB 已匹配完成（越过叶子节点），因此返回 true；
                       当节点 A为空：说明已经越过树 AA 叶子节点，即匹配失败，返回 false ；
                       当节点 A和 B 的值不同：说明匹配失败，返回 false ；
       返回值：
                       判断 A 和 B 的左子节点是否相等，即 recur(A->left, B->left) ；
                       判断 A 和 B 的右子节点是否相等，即 recur(A->right, B->right) 

isSubStructure(A, B)函数：先序遍历树 AA 中的每个节点 a；

        特例处理： 当 树 AA 为空 或 树 BB 为空 时，直接返回 falsefalse ；
        返回值： 若树 B 是树 A 的子结构，则必满足以下三种情况之一，因此用或 || 连接；
                        以 节点 A 为根节点的子树 包含树 BB ，对应 recur(A, B)；
                        树 B 是 树 A 左子树 的子结构，对应 isSubStructure(A->left, B)；
                        树 B 是 树 A 右子树 的子结构，对应 isSubStructure(A->right, B)

class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(!A || !B)  return false;
        return recur(A,B) ||isSubStructure(A->left,B) || isSubStructure(A->right, B);
    }
    bool recur(TreeNode* A, TreeNode* B){
        if(B==nullptr)  return true;
        if(!A || A->val != B->val)  return false;
        return recur(A->left,B->left) && recur(A->right, B->right);
    }
};

4. 二叉树展开成链表

思路：

 1. 将左子树插入到右子树的地方

将原来的右子树接到左子树的最右边节点

考虑新的右子树的根节点，一直重复上边的过程，直到新的右子树为 null

              

代码

class Solution {
public:
    void flatten(TreeNode* root) {
        while(root!=nullptr){
            if(root->left==nullptr){
                root=root->right;
            }
            else{
                TreeNode* cur=root->left;
                while(cur->right!=nullptr){
                    cur=cur->right;
                }
                cur->right=root->right;
                root->right=root->left;
                root->left=nullptr;
                root=root->right;
            }
        }
    }
};