二叉树探索篇Ⅱ

 Leetcode110——平衡二叉树

题目描述：

给定一个二叉树，判断它是否是 平衡二叉树

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

算法思想：

利用后序遍历的思想，记录每个节点的高度，当某个节点的左子树与右子树高度差大于1时，该树不为平衡二叉树。

算法实现：

    int getHeigh(TreeNode* node){
        if(node==NULL) return 0;
        int lh=getHeigh(node->left);
        if(lh==-1) return -1;
        int rh=getHeigh(node->right);
        if(rh==-1) return -1;
        if(abs(lh-rh)>1) return -1;
        else return 1+max(lh,rh);
    }

    bool isBalanced(TreeNode* root) {
        return getHeigh(root)!=-1;
    }

Leetcode257——二叉树的所有路径

题目描述：

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]

示例 2：

输入：root = [1]
输出：["1"]

算法思想：

利用先序遍历的思想（注意观察我们的输出结果，是自顶向下的，所以选择先序比较合适），在每遍历到一个非叶节点时加入临时路径中，当遍历到叶子节点时说明这条路径已经完整的找到，保存到结果集当中。

算法实现：

void getPaths(TreeNode* node,vector<int> path,vector<string> &res){
        path.push_back(node->val);
        //此节点为叶子节点，要将该路径保存到结果集当中
        if(node->left==nullptr && node->right==nullptr) {
            string s="";
            int i;
            for(i=0;i<path.size()-1;i++){
                s=s+to_string(path[i])+"->";
            }
            s+=to_string(path[i]);
            res.push_back(s);
            return;
        }
        if(node->left) {
            getPaths(node->left,path,res);
        }
        if(node->right){
            getPaths(node->right,path,res);
        }
        return;
    }

    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> res;
        getPaths(root,path,res);
        return res;
    }

Leetcode404——左叶子之和

题目描述：

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

输入: root = [1]
输出: 0

算法思想：

利用后序遍历的思想，找到所有的左叶子节点求和，并将结果保存在最接近根节点的左叶子节点返回。

算法实现：

int sumleft(TreeNode* root){
        int sum=0;
        if(root->left) sum+=sumleft(root->left);
        if(root->right) sum+=sumleft(root->right);
        if(root->left!=nullptr && root->left->left==nullptr && root->left->right==nullptr){
            return sum+root->left->val;
        }
        return sum;
    }

    int sumOfLeftLeaves(TreeNode* root) {
        if(root->left==nullptr && root->right==nullptr) return 0;
        return sumleft(root);
    }

Leetcode513——找树左下角的值

题目描述：

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

算法思想：

利用层序遍历的方法，寻找到最后一层的第一个节点即为所求。

算法实现：

int findBottomLeftValue(TreeNode* root) {
        if(root->left==nullptr&&root->right==nullptr) return root->val;
        queue<TreeNode*> q;
        q.push(root);
        int res;
        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(i==0) res=node->val;
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
        }
        return res;
    }

Leetcode112——路径总和

题目描述：

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

算法思想：

利用先序遍历的思想，记录每条路径的和，直至遍历到叶子节点比较该路径和与目标和是否一致，一致返回true，不一致返回false继续找下一条路径，找到一条符合的路径即可功成身退。

算法实现：

bool pathSum(TreeNode* root,int sum,int targetSum){
        bool res=false;
        sum+=root->val;
        if(root->left==nullptr&&root->right==nullptr){
            if(sum==targetSum) return true;
            else return false;
        }
        if(root->left) {
            res=res||pathSum(root->left,sum,targetSum);
            if(res) return true;
        }
        if(root->right) {
            res=res||pathSum(root->right,sum,targetSum);
            if(res) return true;
        }
        return res;
    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root) return false;
        return pathSum(root,0,targetSum);
    }

Leetcode113——路径总和Ⅱ

题目描述：

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

算法思想：

利用先序遍历的思想，没找到一条符合条件的路径，就加入到结果集当中。

算法实现：

void pathSum(TreeNode* root,int sum,int targetSum,vector<int> path,vector<vector<int>> &res){
        sum+=root->val;
        path.push_back(root->val);
        if(root->left==nullptr&&root->right==nullptr){
            //满足条件将这条路径计入到结果集当中
            if(sum==targetSum) res.push_back(path);
            return;
        }
        if(root->left) {
            pathSum(root->left,sum,targetSum,path,res);
        }
        if(root->right) {
            pathSum(root->right,sum,targetSum,path,res);
        }
        return;
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>> res;
        if(!root) return res;
        vector<int> path;
        pathSum(root,0,targetSum,path,res);
        return res;
    }