代码随想录算法训练营第16天 | 第六章 二叉树part04

---

今日记录

---

513.找树左下角的值

Leetcode链接

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL)
            que.push(root);
        int num = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == 0) {
                    num = node->val;
                }
                if (node->left)
                    que.push(node->left);
                if (node->right)
                    que.push(node->right);
            }
        }
        return num;
    }
};

112.路径总和

Leetcode链接

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。

易错点：
1.理解回溯；
2.在代入时，targetSum实际上是：targetSum-root->val;(EX: [1],targetSum=1;)

class Solution {
public:
    bool traversal(TreeNode* node, int count) {
        if (node->left == NULL && node->right == NULL && count == 0)
            return true;
        if (node->left == NULL && node->right == NULL)
            return false;
        if (node->left) {
            count -= node->left->val;
            if (traversal(node->left, count))
                return true;
            count += node->left->val;
        }
        if (node->right) {
            count -= node->right->val;
            if (traversal(node->right, count))
                return true;
            count += node->right->val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL)
            return false;
        return traversal(root, targetSum - root->val);
    }
};

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

Leetcode链接

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0)
            return NULL;

        // 找到后序（左右中）最后一个元素，就是根节点
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        // 如果只有一个节点
        if (postorder.size() == 1)
            return root;

        // 利用根节点，在中序遍历（左中右）中找到根节点位置
        int index;
        for (index = 0; index < inorder.size(); index++) {
            if (inorder[index] == rootValue)
                break;
        }
        // 在中序数组中进行切割：左中序数组和右中序数组
        // 1.切割左序数组：左闭右开区间(index是根节点，不用加进去）
        vector<int> leftInorder(inorder.begin(), inorder.begin() + index);
        vector<int> rightInorder(inorder.begin() + index + 1, inorder.end());

        // 利用切割好的左右序数组在后序遍历中切割出左后序数组和右后序数组
        postorder.resize(postorder.size() - 1);
        vector<int> leftPostorder(postorder.begin(),postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(),postorder.end());

        // 进行递归
        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0)
            return NULL;
        return traversal(inorder, postorder);
    }
};

105.从前序与中序遍历序列构造二叉树

Leetcode链接

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, int preorderBegin,int preorderEnd, vector<int>& inorder, int inoderBegin,int inorderEnd) {
        if (preorderBegin == preorderEnd)
            return NULL;
        int rootValue = preorder[preorderBegin]; // 找到根节点
        TreeNode* root = new TreeNode(rootValue);
        if (preorderBegin - preorderEnd == 1)
            return root;
        // 在中序遍历中找到根节点位置
        int index;
        for (index = inoderBegin; index < inorderEnd; index++) {
            if (inorder[index] == rootValue)
                break;
        }
        // 分割左中序数组和右中序数组
        // vector<int> leftInorder(inorder.begin(),inorder.begin()+index);
        // vector<int> rightInorder(inorder.begin()+index+1,inorder.end());
        int leftInorderBegin = inoderBegin;
        int leftInorderEnd = index;
        int rightInorderBegin = index + 1;
        int rightInorderEnd = inorderEnd;

        // 在前序遍历中分割出左前序数组和右前序数组
        // preorder.resize(preorder.size()-1);//去掉根节点
        // vector<int>
        // leftPreorder(preorder.begin()+1,preorder.begin()+leftInorder.size());
        // vector<int>
        // rightPreorder(preorder.begin()+leftInorder.size(),preorder.end());
        int leftPreorderBegin = preorderBegin + 1;
        int leftPreorderEnd = preorderBegin + index - inoderBegin + 1;
        int rightPreorderBegin = preorderBegin + index - inoderBegin + 1;
        int rightPreorderEnd = preorderEnd;

        // root->left=traversal(leftPreorder,leftInorder);
        // root->right=traversal(rightPreorder,rightInorder);
        root->left = traversal(preorder, leftPreorderBegin, leftPreorderEnd,inorder, leftInorderBegin, leftInorderEnd);
        root->right = traversal(preorder, rightPreorderBegin, rightPreorderEnd,inorder, rightInorderBegin, rightInorderEnd);

        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size() == 0 || inorder.size() == 0)
            return NULL;
        return traversal(preorder, 0, inorder.size(), inorder, 0, inorder.size());
    }
};

---

总结