二叉树路径问题

问题分类

自顶向下

• 从某一结点（不一定是根节点），从上到下寻找路径，到某一节点（不一定是叶节点）结束
  二叉树的所有路径
  求和路径
  路径总和
  路径总和||
  路径总和|||(前缀和)

非自顶向下

• 就是从任意节点到任意节点的路径，不需要自顶向下
  二叉树中的最长路径和
  最长同值路径
  二叉树的直径

解题模板

自顶向下

# 一般路径：
vector<vector<int>>res;
void dfs(TreeNode*root,vector<int>path)
{
    if(!root) return;  //根节点为空直接返回0
    path.push_back(root->val);  //作出选择
    if(!root->left && !root->right) //如果到叶节点  
    {
        res.push_back(path);
        return;
    }
    dfs(root->left,path);  //继续递归
    dfs(root->right,path);
}

# 给定和的路径：
void dfs(TreeNode*root, int sum, vector<int> path)
{
    if (!root)
        return;
    sum -= root->val;
    path.push_back(root->val);
    if (!root->left && !root->right && sum == 0)
    {
        res.push_back(path);
        return;
    }
    dfs(root->left, sum, path);
    dfs(root->right, sum, path);
}

非自顶向下

int res=0;
int maxPath(TreeNode *root) //以root为路径起始点的最长路径
{
    if (!root)
        return 0;
    int left=maxPath(root->left);
    int right=maxPath(root->right);
    res = max(res, left + right + root->val); //更新全局变量  
    return max(left, right);   //返回左右路径较长者
}

题目列表（持续更新）

二叉树的所有路径257

void construct(TreeNode* root,string path,vector<string>& paths){
    if(root != nullptr){
        path+=to_string(root->val);
        if(root->left ==nullptr && root->right == nullptr){
            paths.push_back(path);
        }else{
            path+="->";
            construct(root->left,path,paths);
            construct(root->right,path,paths);
        }
    }
}

vector<string> binaryTreePaths(TreeNode* root) {
    vector<string> paths;
    construct(root,"",paths);
    return paths;
}

求和路径

int dfs(TreeNode* root,int sum){
    if (!root){
        return 0;
    }
    int ret = 0;
    if(root->val == sum){
        ret++;
    }
    ret+=dfs(root->left,sum-root->val);
    ret+=dfs(root->right,sum-root->val);
    return ret;
}

int pathSum(TreeNode* root, int sum) {
    if(!root){
        return 0;
    }
    int ret = dfs(root,sum);
    ret+=pathSum(root->left,sum);
    ret+-pathSum(root->right,sum);
    return ret;
}

路径总和

bool hasPathSum(TreeNode* root, int sum) {
    if(root == nullptr){
        return false;
    }
    if(root->left == nullptr && root->right == nullptr){
        return sum == root->val;
    }
    return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val);
}

路径总和||

vector<int> x1;

void dfs(TreeNode* root , vector<vector<int>>& v,int sum){
    if (!root){
        return;
    }
    x1.emplace_back(root->val);
    if(root->left == nullptr && root->right == nullptr && sum == root->val){
        v.emplace_back(x1);
    }
    dfs(root->left,v,sum-root->val);
    dfs(root->right,v,sum-root->val);
    x1.pop_back();                    //回溯
}

vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
    vector<vector<int>> v;
    if(!root){
        return v;
    }
    dfs(root , v , targetSum);
    return v;
}

路径总和|||(前缀和)

int rootSum(TreeNode* root,int targetSum) {
    if (!root) {
        return 0;
    }
    int ret = 0;
    if (root->val == targetSum) {
        ret++;
    }
    ret += rootSum(root->left, targetSum - root->val);
    ret += rootSum(root->right, targetSum - root->val);
    return ret;
}
int pathSum(TreeNode* root, int targetSum)
{
    if (!root) {
        return 0; 
    }
    int ret = rootSum(root, targetSum);
    ret += pathSum(root->left, targetSum);
    ret += pathSum(root->right, targetSum);
    return ret;
}