代码随想录算法训练营第十七天|110.平衡二叉树、 257. 二叉树的所有路径、404.左叶子之和

最新推荐文章于 2024-05-30 16:17:47 发布

kuiisy

最新推荐文章于 2024-05-30 16:17:47 发布

阅读量39

点赞数

分类专栏：代码随想录算法训练营文章标签：算法 c++ Powered by 金山文档

本文链接：https://blog.csdn.net/kuiisy/article/details/129120619

版权

代码随想录算法训练营专栏收录该内容

48 篇文章 0 订阅

订阅专栏

LeetCode 110 平衡二叉树

题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/

思路：

求高度显然使用递归中的后序遍历的方法简便。

代码：

递归法

/**
 * 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 {
public:
    bool isBalanced(TreeNode* root) {
        int result = getheight(root);
        return (result==-1)?false:true;

    }

    int getheight(TreeNode *node)
    {
        if(node == nullptr) return 0;

        // 左，左子树的处理
        int leftheight = getheight(node->left);
        if(leftheight==-1)  return -1;

        // 右，右子树的处理
        int rightheight = getheight(node->right);
        if(rightheight==-1) return -1;

        //中，在父节点处的处理
        int result = 0;
        if(abs(leftheight-rightheight)>1)
            result = -1;
        else
            result = 1+max(leftheight,rightheight);
        
        return result;
    }


};

总结

想到可以通过计算父节点的左右子树的高度然后用高度去判断父节点是不是平衡二叉树。思路是有的，但是写递归的时候还是出现了问题。在左和右的处理中还是不明白怎么写。

LeetCode 257 二叉树的所有路径

题目链接：https://leetcode.cn/problems/minimum-depth-of-binary-tree/

思路：

该题用到的是前序遍历，先处理父节点然后再去分别处理左右节点。在处理左节点的时候，处理完左节点还需要进行回溯的操作，回溯可以使得数完左节点路径后回过头来数右节点的路径。

这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。

在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。

代码：

递归法

/**
 * 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 {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int>path;
        vector<string>result;
        if(root==nullptr)   return result;
        traversal(root,path,result);
        return result;
    }

    // 因为path使用的是引用，所以需要回溯，把回溯写出来。
    void traversal(TreeNode *node,vector<int>&path,vector<string>&result)
    {
        // 中 ------ 之所以将中放在终止条件前是因为保证可以把叶子节点也放进去路径中
        path.push_back(node->val);

        // 终止条件
        if(!node->left&&!node->right)
        {
            string Path;
            for(int i = 0;i<path.size()-1;i++)
            {
                Path += to_string(path[i]);
                Path += "->";
            }
            Path += to_string(path[path.size()-1]);
            result.push_back(Path);
            return ;
        }
        
        // 左
        if(node->left)
        {
            traversal(node->left,path,result);
            path.pop_back();    // 回溯
        }

        // 右
        if(node->right)
        {
            traversal(node->right,path,result);
            path.pop_back();    // 回溯
        }
    }


};

总结

第一次遇到回溯，看了讲解后，思路是理解了，代码部分还需要多加练习。让我再次写出来，可能还是不太行。

LeetCode 404 左叶子之和

题目链接：https://leetcode.cn/problems/sum-of-left-leaves/

思路：

使用后序遍历的原因：因为要通过递归函数的返回值来累加求取左叶子数值之和。

代码：

递归法

写终止条件的时候，遇到叶子节点并不是要返回它的值，因为无法保证它是左叶子节点。左叶子节点是通过父节点来进行反映的。

在处理”左“的时候，还要注意什么时候添加值，当父节点下面的左节点是左叶子节点的时候，要通过父节点将左叶子节点的值累加起来。

/**
 * 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 {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        // 终止条件
        if(root == nullptr) return 0;
        // 假如是叶子节点也要返回0
        if(!root->left&&!root->right)   return 0;

        // 左
        int leftnumber = sumOfLeftLeaves(root->left);
        // 左子树就是一个左叶子的情况
        if(root->left&&!root->left->left&&!root->left->right)
            leftnumber = root->left->val;

        // 右
        int rightnumber = sumOfLeftLeaves(root->right);

        // 中
        int sum = leftnumber+rightnumber;

        return sum;

    }
};