代码随想录第18天|二叉树

qq_45699949

已于 2024-06-13 22:32:39 修改

阅读量152

点赞数 7

分类专栏：代码随想录文章标签：算法

于 2024-06-08 19:58:22 首次发布

本文链接：https://blog.csdn.net/qq_45699949/article/details/139540533

版权

代码随想录专栏收录该内容

46 篇文章 0 订阅

订阅专栏

513.找树左下角的值

在这里插入图片描述

此处输出为 3, 找到最后一层, 然后寻找最左边的值

题解

思路: 层序遍历

直接找到最后一层, 然后输出最后一层的第一个元素

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> myqueue;
        if (root)
            myqueue.push(root);
        int result = 0;
        while (!myqueue.empty()) {
            int size = myqueue.size();
            //result = myqueue.front()->val;//位置均可
            for (int i = 0; i < size; i++) {
                TreeNode* tem = myqueue.front();
                if (i == 0) result = tem->val; // 记录最后一行第一个元素
                myqueue.pop();
                if (tem->left) myqueue.push(tem->left);
                if (tem->right) myqueue.push(tem->right);
            }
        }
        return result;
    }
};

思路: 递归

存在回溯的过程
找到叶子节点，然后保留深度最高的一个

class Solution {
public:
    int result = 0;
    int depth_count = -1;
    void find(TreeNode* Node, int depth) {
        if (Node->left == nullptr && Node->right == nullptr) {
            if (depth > depth_count) {
                depth_count = depth;//叶子节点为结束条件
                result = Node->val;
            }
            return;
        }
        if (Node->left) find(Node->left, depth + 1);
        if (Node->right) find(Node->right, depth + 1);
        return;
    }
     void find(TreeNode* Node, int depth) {
    	if (Node == nullptr) return; //若进入空节点的特殊处理
        if (Node->left == nullptr && Node->right == nullptr) {
            if (depth > depth_count) {
                depth_count = depth;//叶子节点为结束条件
                result = Node->val;
            }
            return;
        }
        find(Node->left, depth + 1);
        find(Node->right, depth + 1);
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        find(root, 1);
        return result;
    }
};

在这里插入图片描述

112. 路径总和

在这里插入图片描述

题解

在这里插入图片描述

思路: 迭代回溯实现

class Solution {
public:
    bool judge(TreeNode* node, int value) {
        if (node == nullptr) //避免传入为null的情况
            return false;
        if (node->left == nullptr && node->right == nullptr) {
            if (value == node->val)
                return true;
            else
                return false;
        }
        bool res1, res2;
        res1 = judge(node->left, value - node->val);
        res2 = judge(node->right, value - node->val);

        return res1 || res2;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        return judge(root, targetSum);
    }
};

在这里插入图片描述

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

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历
请你构造并返回这颗二叉树
在这里插入图片描述
需要重新回看思路

参考

在这里插入图片描述

相关题目

112.路径总和

113. 路径总和ii

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> result;
    vector<int> result_tem;

    void judge(TreeNode* node, int target) {
        if (node == nullptr) return;//避免一开始传入的节点为nullptr
        if (node->left == nullptr && node->right == nullptr) {
            if (target == node->val) {
                result_tem.push_back(node->val);
                result.push_back(result_tem);
                result_tem.pop_back();
                return;
            } else {
                return;
            }
        }

        if (node->left) {//可以忽略该条件，由最上面的条件覆盖
            result_tem.push_back(node->val);
            judge(node->left, target - node->val);
            result_tem.pop_back();
        }
        if (node->right) {
            result_tem.push_back(node->val);
            judge(node->right, target - node->val);
            result_tem.pop_back();
        }
        return;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        judge(root, targetSum);
        return result;
    }
};