代码随想录算法训练营day18 | LeetCode 513. 找树左下角的值 112. 路径总和 106. 从中序与后序遍历序列构造二叉树

513. 找树左下角的值（题目链接：力扣）

思路：典型的二叉树便利题，可以考录用递归或者迭代，递归的话就是正常的前序遍历或者中序遍历，但是都需要定义一个全局变量记录深度，当每第一次达到最大深度时（遍历到叶子节点的时候）记录该节点的值。迭代就是用层序便利了，每次拿出每层第一个节点的值记录下来，当层序遍历完，最后一次赋的值也就是数左下角的值了。

struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(): val(0), left(NULL), right(NULL){}
}

int depth = 0;
int result = 0;

void getDepth(TreeNode* root, int tmpDepth){
    if(root->left == NULL && root->right == NULL){
        if(tmpDepth > depth){
            result = root->val;
            depth = tmpDepth;
        }
    }
    if(root->left){
        getDepth(root->left, tmpDepth + 1);
    } 
    if(root->right){
        getDepth(root->right, tmpDepth + 1);
    }
}

int findBottomLeftValue(TreeNode* root) {
    getDepth(root, 1);
    return result;
}

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

112. 路径总和（题目链接：力扣）

思路：典型的回溯法，首先讲递归的做法，每次迭代要传给子树的参数包括节点指针、到本节点为止的值的和，遍历到叶子结点时进行判断。（这种做法也可以不需要传num，直接每次吧targetSum减去本节点的值再传给子树，这样可以少一个参数，而且也不用另外写一个函数）

struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(): val(0), left(NULL), right(NULL){}
}

bool flag = false;

void traversal(TreeNode* root, int num, int targetSum){
    if(root->left == NULL && root->right == NULL){
        if(num + root->val == targetSum) flag = true;
    }
    if(root->left) traversal(root->left, root->val + num, targetSum);
    if(root->right) traversal(root->right, root->val + num, targetSum);
}

bool hasPathSum(TreeNode* root, int targetSum) {
    if(root == NULL) return false;
    traversal(root, 0, targetSum);
    return flag;
}

第二种迭代的做法，其实有点画蛇添足，比递归做法要复杂不少，但也算锻炼对树的遍历算法练习。因为节点指针和暂时和值必不可少，所以需要往stack里面push进pair<TreeNode*, int>才行，然后还是碰到节点指针进行判断。

bool hasPathSum(TreeNode* root, int targetSum) {
    if(root == NULL) return false;
    stack<pair<TreeNode*, int>> st;
    st.push(pair<TreeNode*, int>(root, 0));
    while(!st.empty()){
        pair<TreeNode*, int> node = st.top();
        st.pop();
        if(node.first->left == NULL && node.first->right == NULL && node.second + node.first->val == targetSum) return true;
        if(node.first->right) st.push(pair<TreeNode*, int>(node.first->right, node.second + node.first->val));
        if(node.first->left) st.push(pair<TreeNode*, int>(node.first->left, node.second + node.first->val));
    }
}

leetcode上还有一道求路径和的题和这个差不多力扣

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

思路：又是一道经典的二叉树构造题，注意前后序遍历和中序遍历的规律即可。（tips：如果用到数组做形参，就可以在函数体内不再构造新数组）

TreeNode* traversal(vector<int>& inOrder, int inStart, int inEnd, vector<int>& postOrder, int postStart, int postEnd){
    int size = inEnd - inStart;
    if(size == 0) return NULL;
    TreeNode* root = new TreeNode(postOrder[postEnd - 1]);
    if(size == 1) return root;
    int rootIndex;
    for(rootIndex=inStart; rootIndex<inEnd; rootIndex++){
        if(inOrder[rootIndex] == root->val) break;
    }
    root->left = traversal(inOrder, inStart, rootIndex, postOrder, postStart, postStart+rootIndex-inStart);
    root->right = traversal(inOrder, rootIndex+1, inEnd, postOrder, postStart+rootIndex-inStart, postEnd-1);
    return root;
}

TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
    return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
}