leetcode刷题. 404. 437. 572. 二叉树遍历easy复习-CSDN博客

本文深入探讨了树形数据结构中的递归算法应用，包括左叶子之和、路径总和III及子树匹配问题的解决策略。通过双递归、三重递归等技巧，实现了对树的遍历与子树比较，提供了清晰的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

    int sumOfLeftLeaves(TreeNode* root) {

        if(nullptr == root)
            return 0;

        int left = dfs(root->left, 1);
        int right = dfs(root->right, 0);
        
        return left + right;
    }
    // flag为1表示左节点
    int dfs(TreeNode* node, int flag) {

        if(nullptr == node)
            return 0;

        if(nullptr == node->left && nullptr == node->right && flag) {
            return node->val;
        }

        int left = dfs(node->left, 1);
        int right = dfs(node->right, 0);

        return left + right;
    }

437. 路径综合iii

解法：双递归，其实可以拆封出一个从根节点求路径综合的子问题。

    void pathSumInclude(TreeNode *root, int sum, int nowsum, int &count) {

        if(nullptr == root)
            return;

        count += nowsum + root->val == sum ? 1 : 0;


        pathSumInclude(root->left, sum, nowsum + root->val, count);
        pathSumInclude(root->right, sum, nowsum + root->val, count);
    }

    void traverse(TreeNode *root, int sum, int &count) {

        if(nullptr == root)
            return;

        // 先序
        pathSumInclude(root, sum, 0, count);

        traverse(root->left, sum, count);
        traverse(root->right, sum, count);
    }
 
    int pathSum(TreeNode* root, int sum) {

        if(nullptr == root)
            return 0;
        
        int count = 0;
        traverse(root, sum, count);
        return count;
    }

572. 另一个数的子树

除去递归之外，还可以中序遍历并采用kmp算法检查是否有匹配的子串。

    bool compare(TreeNode *s, TreeNode *t) {

        if(nullptr == s && nullptr == t)
            return true;
        
        if(nullptr == s || nullptr == t)
            return false;

        return (s->val == t->val) && compare(s->left, t->left) && compare(s->right, t->right);       
    }

    bool traverse(TreeNode *s, TreeNode *t) {

        if(nullptr == s || nullptr == t)
            return false;
     
        bool b = compare(s, t);
        bool l = nullptr != s->left ? traverse(s->left, t) : false;
        bool r = nullptr != s->right ? traverse(s->right, t) : false;

        return b || l || r;
    }

    bool isSubtree(TreeNode* s, TreeNode* t) {
        return traverse(s, t);
    }

这里在延申一下：s的子树中有没有和t的子树具有相同结构？

这里使用三重递归的思路：

 bool cmp(TreeNode* s, TreeNode* t) {

         if (nullptr == s && nullptr == t)
                 return true;

         if (nullptr == s || nullptr == t)
                 return false;

         return cmp(s->left, t->left) && cmp(s->right, t->right);
 }

 bool compare(TreeNode* s, TreeNode* t) {

         if (nullptr == s || nullptr == t)
                 return false;

         bool b = cmp(s, t);
         bool l = nullptr != t->left ? compare(s, t->left) : false;
         bool r = nullptr != t->right ? compare(s, t->right) : false;

         return b || l || r;
 }

 bool traverse(TreeNode* s, TreeNode* t) {

         if (nullptr == s || nullptr == t)
                 return false;

         bool b = compare(s, t);
         bool l = nullptr != s->left ? traverse(s->left, t) : false;
         bool r = nullptr != s->right ? traverse(s->right, t) : false;

         return b || l || r;
 }

 bool isSubtree(TreeNode* s, TreeNode* t) {
         return traverse(s, t);
 }