代码随想录【Day 18】 | 513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树

最新推荐文章于 2024-07-19 19:25:43 发布

Pittsman

最新推荐文章于 2024-07-19 19:25:43 发布

阅读量47

点赞数

分类专栏： LeetCode 代码随想录训练营文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/Pittsman/article/details/128881074

版权

LeetCode 同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

代码随想录训练营

24 篇文章 0 订阅

订阅专栏

本文介绍了LeetCode上的几个二叉树问题，包括找树左下角的值、路径总和、路径总和II和从中序与后序遍历序列构造二叉树，分别给出了层序遍历和递归的解题思路与代码实现，强调了递归解决此类问题的关键点。

摘要由CSDN通过智能技术生成

代码随想录【Day 18】 | 513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树

513.找树左下角的值
层序遍历
- 代码实现：
递归
- 代码实现：
112. 路径总和
递归
- 代码实现：
113.路径总和ii
106.从中序与后序遍历序列构造二叉树

513.找树左下角的值

题目链接：513.找树左下角的值

卡尔文解

视频讲解

解题思路及注意事项：

本题要找出树的最后一行的最左边的值。此时大家应该想起用层序遍历是非常简单的了，反而用递归的话会比较难一点。

层序遍历

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {

private:
    queue<TreeNode*> que;
    int result;

public:
    int findBottomLeftValue(TreeNode* root) {

        if( !root ) return INT_MIN;
        que.push( root );

        while( !que.empty() ){

            int size = que.size();

            for( int i = 0; i < size; i++ ){
                
                TreeNode *node = que.front();
                que.pop();

                if( i == 0 ){
                    result = node->val;
                }

                if( node->left ) que.push( node->left );
                if( node->right ) que.push( node->right );
            }
        }

        return result;
    }
};

递归

咋眼一看，这道题目用递归的话就就一直向左遍历，最后一个就是答案呗？

没有这么简单，一直向左遍历到最后一个，它未必是最后一行啊。

我们来分析一下题目：在树的最后一行找到最左边的值。

首先要是最后一行，然后是最左边的值。

如果使用递归法，如何判断是最后一行呢，其实就是深度最大的叶子节点一定是最后一行。

如果对二叉树深度和高度还有点疑惑的话，请看：110.平衡二叉树 (opens new window)。

所以要找深度最大的叶子节点。

那么如何找最左边的呢？可以使用前序遍历（当然中序，后序都可以，因为本题没有中间节点的处理逻辑，只要左优先就行），保证优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {

private:
    int maxDepth = INT_MIN;
    int result;

    void traverse( TreeNode *node, int current_depth ){

        if( !node ) return;

        if( current_depth > maxDepth ){
            result = node->val;
            maxDepth = current_depth;
        }

        if( node->left ){
            current_depth++;
            traverse( node->left, current_depth );
            current_depth--;
        }

        if( node->right ){
            current_depth++;
            traverse( node->right, current_depth );
            current_depth--;
        }
    }

public:
    int findBottomLeftValue(TreeNode* root) {

        if( !root ) return INT_MIN;

        traverse( root, 0 );
        return result;
    }
};

112. 路径总和

题目链接：112. 路径总和

卡尔文解

视频讲解

解题思路及注意事项：

递归

可以使用深度优先遍历的方式（本题前中后序都可以，无所谓，因为中节点也没有处理逻辑）来遍历二叉树

确定递归函数的参数和返回类型
参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。

再来看返回值，递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）
如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。（这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）
如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况)

而本题我们要找一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？

如图所示：

在这里插入图片描述

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    
    bool traverse( TreeNode* node, int count ){

        if( !node->left && !node->right && !count ) 
            return true;
        
        if( !node->left && !node->right ) 
            return false;

        if( node->left ){
            count -= node->left->val;
            if (traverse( node->left, count )) return true;
            count += node->left->val;
        }

        if( node->right ){
            count -= node->right->val;
            if (traverse( node->right, count ) ) return true;
            count += node->right->val;
        }

        return false;
    }


public:
    bool hasPathSum(TreeNode* node, int targetSum) {

        if( !node ) return false;
        
        return( traverse( node, targetSum - node->val ) );

    }
};

113.路径总和ii

题目链接：113.路径总和ii

卡尔文解

解题思路及注意事项：

在这里插入图片描述

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

    void traverse( TreeNode *node, int count ){

        if( !node->left && !node->right && !count ){
            result.push_back( path );
            return;
        }

        if( !node->left && !node->right ){
            return;
        }

        if( node->left ){
            count -= node->left->val;
            path.push_back( node->left->val );

            traverse( node->left, count );

            path.pop_back( );
            count += node->left->val;

        }

        if( node->right ){
            count -= node->right->val;
            path.push_back( node->right->val );

            traverse( node->right, count );

            path.pop_back( );
            count += node->right->val;

        }

        return;
    }

public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {

        if( !root ) return result;

        path.push_back( root->val );
        traverse( root, targetSum - root->val );

        return result;
    }
};

106.从中序与后序遍历序列构造二叉树

题目链接：106.从中序与后序遍历序列构造二叉树

卡尔文解

解题思路及注意事项：

首先回忆一下如何根据两个顺序构造一个唯一的二叉树，相信理论知识大家应该都清楚，就是以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

如果让我们肉眼看两个序列，画一棵二叉树的话，应该分分钟都可以画出来。

流程如图：
在这里插入图片描述
那么代码应该怎么写呢？

说到一层一层切割，就应该想到了递归。
来看一下一共分几步：

第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）
第五步：切割后序数组，切成后序左数组和后序右数组
第六步：递归处理左区间和右区间

不难写出如下代码：（先把框架写出来）
在这里插入图片描述

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {

private:
    TreeNode *traverse( vector<int>& inorder, vector<int>& postorder ){

        //第一步：如果后序数组为空的话，说明是空节点了
        if( postorder.empty() ){ return NULL; }

        //第二步：如果后序数组不为空，那么取最后一个元素，就是树的根节点。然后以此作为中序数组的切割点。
        int val = postorder[ postorder.size() - 1 ];
        TreeNode *node = new TreeNode( val );

        if( postorder.size() == 1 ) return node;

        //第三步：去中序数组找到后序数组最后一个元素的位置，作为切割点。
        int partitionIdx;
        for( partitionIdx = 0; partitionIdx < inorder.size(); partitionIdx++ ) {
            if( inorder[ partitionIdx ] == node->val)
                break;
        }

        //第四步： 切割中序数组，得到 中序左数组和中序右数组
        //遵从  左闭右开区间：[0, partitionIdx)
        vector<int> leftInorder( inorder.begin(), inorder.begin() + partitionIdx );

        // [ partitionIdx + 1, end )
        vector<int> rightInorder( inorder.begin() + partitionIdx + 1, inorder.end());

        // postorder 舍弃末尾元素
        postorder.resize( postorder.size() - 1 );

        //第五步： 切割后序数组，得到 后序左数组和后序右数组
        //中序数组大小一定是和后序数组的大小相同的（这是必然）.

        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());

        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        node->left = traverse( leftInorder, leftPostorder );
        node->right = traverse( rightInorder, rightPostorder );

        return node;
    }


public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {

        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traverse(inorder, postorder);
    }
};

Pittsman

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码随想录【Day 18】 | 513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树

代码随想录【Day 18】 | 513.找树左下角的值、112. 路径总和、113.路径总和ii、106.从中序与后序遍历序列构造二叉树
复制链接

扫一扫