leetcode 树题目整理二（111、104、112、113、437，687二叉树的最大/最小深度，路径总和123，最长同值路径）

最新推荐文章于 2021-08-28 17:23:14 发布

zaizaiaaaaa

最新推荐文章于 2021-08-28 17:23:14 发布

阅读量183

点赞数

分类专栏： leetcode题目整理

本文链接：https://blog.csdn.net/qq_41807225/article/details/102832367

版权

leetcode题目整理专栏收录该内容

22 篇文章 1 订阅

订阅专栏

111 二叉树的最小深度

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
采用DFS深度优先搜索，参数为当前节点及其对应深度，在每一层搜索中，设置变量ans为一个较大值，当遍历到叶子节点时，更新ans，并传回上一层，在向上传递过程中，比较左右子树传回的深度，并更新保持最小值。

class Solution {
public:
    int findMinDepth(TreeNode* root,int depth){
        int ans = 1e9;
        if(root->left != NULL)
            ans = min(findMinDepth(root->left,depth + 1),ans);
        if(root->right != NULL)
            ans = min(findMinDepth(root->right,depth + 1),ans);
        if(root->left == NULL && root->right == NULL)
            ans = min(ans,depth);
        return ans;
    }
    int minDepth(TreeNode* root) {
        if(root == NULL)
            return 0;
        return findMinDepth(root,1);
    }
};

104 二叉树的最大深度

二叉树的深度（最大深度）为根节点到最远叶子节点的最长路径上的节点数。
采用DFS深度优先搜索，参数为当前节点及其对应深度，在每一层搜索中，设置变量ans等于当前深度值，当遍历到叶子节点时，直接返回ans（即该叶子节点对应深度），并传回上一层，在向上传递过程中，比较左右子树传回的深度，并更新保持最大值。

class Solution {
public:
    int dfs(TreeNode* root, int depth) {
        int ans = depth;
        if(root -> left != NULL)
            ans = max(ans, dfs(root -> left, depth + 1));
        if(root -> right != NULL)
            ans = max(ans, dfs(root -> right, depth + 1));
        return ans;
    }
    int maxDepth(TreeNode* root) {
        int ans = 0;
        if(root == NULL)
            return ans;
        ans = dfs(root, 1);
        return ans;
    }
};

112 路径总和

题目描述： 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。返回true或者false。
采用DFS深度优先遍历，参数为当前节点，目标路径和以及从根节点到当前节点的路径和。当遍历到叶子节点时，比较当前路径和是否等于目标路径和，如果等于，返回true，并返回上一层。每一层搜索中，默认变量ans为false，ans与左右子树的返回值进行或等运算，如果有一条路径的返回值为true，则根节点的返回值为true。
|=：或等运算，类比于+= ，-=运算。

class Solution {
public:
    bool dfs(TreeNode* root, int pathSum, int sum) {
        bool ans = false;
        if(root -> left != NULL)
            ans |= dfs(root -> left, pathSum + root -> val, sum);
        if(root -> right != NULL)
            ans |= dfs(root -> right, pathSum + root -> val, sum);
        if(root -> left == NULL && root -> right == NULL && pathSum + root -> val == sum)
            ans = true;
        return ans;
    }
    bool hasPathSum(TreeNode* root, int sum) {
        if(root == NULL)
            return false;
        return dfs(root, 0, sum);
    }
};

113 路径总和2

题目描述： 给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。返回二维数组。
采用DFS深度优先搜索，参数包括当前节点，目标路径总和，答案路径数组以及当前路径数组。当遍历到叶子结点且该路径总和等于目标路径总和时，将当前路径数组push到答案数组，每遍历完一个节点及其左右子树后，在当前路径数组中pop掉当前节点并返回上一层继续遍历。

class Solution {
public:
    void dfs(TreeNode* root, int sum, vector<vector<int>>& ans, vector<int>& tmp) {
        tmp.push_back(root -> val);
        if(root -> left != NULL) 
            dfs(root -> left, sum - root -> val, ans, tmp);
        if(root -> right != NULL)
            dfs(root -> right, sum - root -> val, ans, tmp);
        if(root -> left == NULL && root -> right == NULL && sum - (root -> val) == 0)
            ans.push_back(tmp);
        tmp.pop_back();
        return ;
    }
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> ans;
        if(root == NULL)
            return ans;
        vector<int> tmp;
        dfs(root, sum, ans, tmp);
        return ans;
    }
};

437 路径总和3

题目描述： 找出路径和等于给定数值的路径总数。路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。返回值为路径总数。
DFS，保存每个节点到根节点的路径总和，存入数组path_sum中，在向下dfs的过程中，遍历当前path_sum中的每一个值，和当前节点对应的路径和相减，符合给定数值，则ans+1。遍历过节点（以及节点的左右子树）后，将当前节点对应的路径和pop出数组，并返回上一层搜索过程。

class Solution {
public:
    void dfs(TreeNode* root, int node_sum, vector<int>& path_sum, int& ans, int sum) {
        node_sum += root -> val;
        for(int i = 0; i < path_sum.size(); i++) {
            if(node_sum - path_sum[i] == sum)
                ans++;
        }
        path_sum.push_back(node_sum);
        if(root -> left != NULL) 
            dfs(root -> left, node_sum, path_sum, ans, sum);
        if(root -> right != NULL) 
            dfs(root -> right, node_sum, path_sum, ans, sum);
        path_sum.pop_back();
        return ;
    }
    int pathSum(TreeNode* root, int sum) {
        int ans = 0;
        if(root == NULL)
            return ans;
        vector<int> path_sum;
        path_sum.push_back(0);
        dfs(root, 0, path_sum, ans, sum);
        return ans;
    }
};

687 最长同值路径

题目描述： 给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。这条路径可以经过也可以不经过根节点。两个节点之间的路径长度由它们之间的边数表示。
DFS，每层遍历返回左子树和右子树中具有相同值的最大长度，如果当前节点与其左节点的值不相等，left_dep清零，同理right_dep。如果相等，则在返回值的基础上加一。遍历每个节点时，更新ans值ans = max(ans, left_dep + right_dep);。

class Solution {
public:
    int dfs(TreeNode* root, int &ans) {
        int left_dep = 0, right_dep = 0;
        if(root -> left != NULL) {
            left_dep = dfs(root->left, ans);
            if(root -> val == root ->left -> val)
                left_dep += 1;
            else
                left_dep = 0;
        }
        if(root -> right != NULL) {
            right_dep = dfs(root->right, ans);
            if(root -> val == root ->right -> val)
                right_dep += 1;
            else
                right_dep = 0;
        }
        ans = max(ans, left_dep + right_dep);
        return max(left_dep, right_dep);
    }
    
    int longestUnivaluePath(TreeNode* root) {
        int ans = 0;
        if(root == NULL)
            return ans;
        dfs(root, ans);
        return ans;
    }
};