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

---

一、513.找树左下角的值

题目链接

代码如下：

class Solution {
public: 
        int maxDepth = INT_MIN;
        int result;
        void traversal(TreeNode* root, int depth) {
            if (root->left == NULL &&root->right == NULL) { //终止条件：遇到叶子节点
                if (depth > maxDepth) { // 如果叶子节点深度大于maxDepth
                    maxDepth = depth; // 更新最大深度
                    result = root->val; // 最大深度最左边的数值，【为什么？】
                }
                return;
            }
         if (root->left) { // 左
            depth++; // 向下遍历了，深度加1
            traversal(root->left, depth);
            depth--; // 回溯，深度减一
        }
        if (root->right) {
            depth++;
            traversal(root->right, depth);
            depth--;
        }
       
        }
        int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return result;
    }
};

二、112.路径总和、113.路径总和II

112.路径总和

题目链接

代码如下：

class Solution {
public:
    bool traversal(TreeNode* cur,int count) {
        //终止条件：如果遇到叶子节点且计数为0，说明找到合法的路径；如果遇到叶子节点但计数不为0，返回false
        if (cur->left == NULL && cur->right == NULL && count == 0) return true;
        if (cur->left == NULL && cur->right == NULL && count != 0) return false;

        if (cur->left) { //向左孩子遍历的逻辑，先判断是否为空
            count -= cur->left->val; //递归，处理节点
            if (traversal(cur->left, count)) return true;
            count += cur->left->val; //回溯，撤销处理结果 （用自己的话来说：保留向右边遍历的可能）
        }

        if (cur->right) {
            count -= cur->right->val;
            if (traversal(cur->right, count)) return true;
            count += cur->right->val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL) return false;
        return traversal(root, targetSum - root->val); //主函数中就传入targetSum减去root->val
    }
};

113.路径总和II

题目链接

代码如下：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void traversal (TreeNode* cur, int count) { // 因为要遍历整个数，递归函数不需要返回值，最后结果收集在result中
        // 终止条件：遍历到叶子节点且count为0，将遍历所经过的路径放入result中；若遍历到叶子节点count不为0，则直接return
        if (cur->left == NULL && cur->right == NULL && count == 0) {
            result.push_back(path);
            return ;
        }
        if (cur->left == NULL && cur->right == NULL && count != 0) return ;

        // 单层递归逻辑：若左孩子不为空，将左孩子的值放入path中，count减去该值，对左孩子的左孩子进行遍历，回溯，count恢复，path恢复
        if (cur->left) {
            path.push_back(cur->left->val);
            count -= cur->left->val;
            traversal(cur->left, count);
            count += cur->left->val;
            path.pop_back();
        }
         if (cur->right) {
            path.push_back(cur->right->val);
            count -= cur->right->val;
            traversal(cur->right, count);
            count += cur->right->val;
            path.pop_back();
        }
        return ;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        result.clear(); // 将result的size（当前储存元素的数量）置为0（但不会改变result的容量，不会释放程序分配的动态内存，真正释放内存的是析构函数）
        path.clear();
        if (root == NULL) return result;
        path.push_back(root->val);
        traversal(root, targetSum - root->val);
        return result;

    }
};

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

题目链接

代码如下：

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        // 第一步：如果数组大小为0，说明为空节点
        if (postorder.size() == 0) return NULL;
        
        // 第二步：取后序最后一个元素为节点元素
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);
        // 后序的数组大小为1，即为叶子节点
        if (postorder.size() == 1) return root;

        // 第三步：找到节点元素的值在中序数组中的位置，作为切割点
        int delimiterIndex;
        for(delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        // 第四步：切割中序数组(左闭右开)[0,delimiterIndex),[delimiterIndex+1,end)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

        // 第五步：切割后序数组，左后序的长度为左中序的长度，右后序的长度为右中序的长度[0,leftInorder.size),(leftInorder.size,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);
    }
};