Day.14 | 513.找树左下角的值 112.路径总和 前中后序构造二叉树

513.找树左下角的值

要点：理解题意，找左下角的值，就是找最大深度最左边节点的值，显然第一时间就能想到层序遍历，用递归法加深一下对回溯的理解

class Solution {
public:
    int maxDepth = INT_MIN;
    int result = NULL;
    void traversal(TreeNode* node, int depth) {
        if (node->left == nullptr && node->right == nullptr) {
            if (maxDepth < depth) {
                maxDepth = depth;
                result = node->val;
            }
            return;
        }
        if (node->left) {
            depth++;
            traversal(node->left, depth);
            depth--;
        }
        if (node->right) {
            depth++;
            traversal(node->right, depth);
            depth--;
        }
    }

    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return result;
    }
};

112.路径总和

要点：和是一路减下去，减到叶子节点的时候为0，就是找到了合适的路径。能想到这一点，遍历要怎么处理单节点的思路就有了

class Solution {
public:
    bool traversal(TreeNode* node, int sum) {
        if (node->left == nullptr && node->right == nullptr) {
            if (sum == 0)
                return true;
            else
                return false;
        }
        if (node->left) {
            sum -= node->left->val;
            if (traversal(node->left, sum))
                return true;
            sum += node->left->val;
        }
        if (node->right) {
            sum -= node->right->val;
            if (traversal(node->right, sum))
                return true;
            sum += node->right->val;
        }
        return false;
    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr)
            return false;
        return traversal(root, targetSum - root->val);
    }
};

前中后序构造二叉树

要点：从前中，中后均可以构造二叉树，因为前序和后序可以确定root节点，通过root节点和中序，可以分离出左右序列，通过分离出来的左右序列，可以分离前后序，再通过递归，就可以确定二叉树的结构，从而构造出二叉树

/** 从中后序构造 */
class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0)
            return nullptr;
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);
        if (postorder.size() == 1)
            return root;

        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size();
             delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue)
                break;
        }

        vector<int> leftInorder(inorder.begin(),
                                inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 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 nullptr;
        return traversal(inorder, postorder);
    }
};

/** 从前中序构造 */
class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size() == 0)
            return nullptr;
        int rootValue = preorder[0];
        TreeNode* root = new TreeNode(rootValue);
        if (preorder.size() == 1)
            return root;

        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size();
             delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue)
                break;
        }

        vector<int> leftInorder(inorder.begin(),
                                inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1,
                                 inorder.end());

        vector<int> leftPreorder(preorder.begin() + 1,
                                 preorder.begin() + 1 + leftInorder.size());
        vector<int> rightPreorder(preorder.begin() + 1 + leftInorder.size(),
                                  preorder.end());

        root->left = traversal(leftPreorder, leftInorder);
        root->right = traversal(rightPreorder, rightInorder);
        return root;
    }

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