算法学习打卡day18｜513.找树左下角的值、112. 路径总和、106.从中序与后序或前序遍历序列构造二叉树-CSDN博客

本文链接：https://blog.csdn.net/weixin_45124219/article/details/133799566

513.找树左下角的值

力扣题目链接
题目描述：
给定一个二叉树的根节点 root，请找出该二叉树的最底层最左边节点的值。
假设二叉树中至少有一个节点。

思路：

迭代法：迭代法比较简单，直接层次遍历，取最后一层的第一个节点即可
递归法：由于是求最后一层的第一个节点，那么需要找到最大深度的那层，然后取那一层的第一个节点，有两个问题：怎么找到最后一层和怎么知道是不是第一个节点。
- 第一个问题：定义一个全局的深度代表最大深度，遍历的时候依次比较，同时记录最大层数所对应的节点值
- 第二个问题，怎么确定是第一个节点，这个我们可以采用前序遍历的方法，每次遍历的都是先从左子树遍历，只有左子树为空时，才会走到右子树，这样max当取到最大值时，第一次拿到的一定是最左边的节点（后续即使也是最大深度那一层的也不会更新了）
- 接下来递归三部曲：
  - 确定函数参数和返回值：函数参数为根节点和当前层的深度depth，返回值为void，因为结果集在全局的result
  - 函数退出条件：当节点为空的时候，return即可。
  - 单步处理逻辑：当遇到叶子节点，且层数比max_depth大的时候，更新result和max_depth，然后依次递归左右子树（这里对顺序没有要求，先遍历哪个都可以）
  - 这里有回溯的思想，在求完左子树的时候，注意把depth回溯，下面代码把回溯逻辑隐藏了traversal(root->left, depth + 1);这里depth没有发生改变，其实是先++，再–。

代码实现：

//递归法
int max_depth = 0;
    int result = 0;
    void traversal(TreeNode* root, int depth) {
        if (root == nullptr) return;
        depth++;
        if (!root->left && !root->right && max_depth < depth) {
            max_depth = depth;
            result = root->val;
        }
        /*depth++;
        traversal(root->left, depth);
        depth--;//体现的回溯的思想，在求完左子树的深度后，在求右子树深度前，进行回溯
        depth++;
        traversal(root->right, depth);
        depth--;*/
        //改写后如下
        traversal(root->left, depth + 1);
        traversal(root->right, depth + 1); 
    }
    int findBottomLeftValue(TreeNode* root) {
        if (root == nullptr)    return 0;
        int depth = 0;
        traversal(root, depth);
        return result;
    }

迭代法：

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

112. 路径总和

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

思路：

递归法：采用前序遍历，先判断是否是叶子节点，然后再判断是否符合当前路径，符合就返回true，不符合就递归左右子树，下面是递归三部曲：
- 确定函数参数和返回值：函数参数为根节点，和用来判断是否符合target的数字，初始值为target，每遍历一个节点就减去该节点，直到叶子节点时，如果它为0，那么就是我们要找的路径。返回值为true，因为只要找到一条路径我们就可以立刻退出了，不符合就返回true。
- 单步处理逻辑：左右节点非空就递归左右节点，注意处理返回值，只要返回值是true，就可以返回了，另外这里也有回溯思想，在递归左子树后，count要回到递归之前的结果，来让右子树使用。

代码实现

bool traversal(TreeNode* root, int count) {
        if (!root->left && !root->right) {
           if (count == 0) {
               return true;
           } else {
               return false;
           }
        }
        if (root->left) {
            if (traversal(root->left, count - root->left->val)) {
              return true;
            }
        }
        if (root->right) {
            if (traversal(root->right, count - root->right->val)) {
              return true;
            }
        } 
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr)    return false;
        return traversal(root, targetSum - root->val);
    }

迭代法：和求所有叶子路径那道题类似，用前序遍历（因为从根节点走），然后把路径和存起来，遇到叶子节点就判断，如果是求所有符合条件的路径这道题，就continue然后继续找。

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

拓展题：求所有符合条件的路径

思路：上上面题一样，就是需要加个path参数，存储路径。另外不需要处理返回值了，所以改为void。
- 注意count和path的回溯思想，稍不注意就会错！！！

代码实现：

vector<vector<int>> results;
    void traversal(TreeNode* root, int count, vector<int>& path) {
        if (!root->left && !root->right) {
            if (count == 0) {
                results.push_back(path);
                return;
            }
        }
        if (root->left) {
            path.push_back(root->left->val);
            traversal(root->left, count - root->left->val, path);
            path.pop_back();
        }
        if (root->right) {
            path.push_back(root->right->val);
            traversal(root->right, count - root->right->val, path);
            path.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if (root == nullptr)   return {};
        vector<int> path;
        path.push_back(root->val);
        traversal(root, targetSum - root->val, path);
        return results;
    }

06.从中序与后序或前序遍历序列构造二叉树

力扣题目链接：.从中序与后遍历序列构造二叉树、从中序与后遍历序列构造二叉树
题目描述：
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树。

思路：

提到一层一层切割，就应该想到了递归。
首先要知道后序遍历时，根节点在最后一个元素，而前序遍历根节点在第一个元素，这样可以通过这个去从中序遍历里找根节点，从而得到左右区间，最后递归左右子区间就可以了。
步骤分为六步：
- 第一步：判断根节点是否为空，如果为空返回nullptr
- 第二步：从后序数组取最后一个元素作为（前序遍历为第一个元素）根节点
- 第三步：从中序遍历中查找到根节点的位置，获取root_index
- 第四步：根据index，拆分中序遍历为左右子区间，即左右子树
- 第五步：因为不论前中后序遍历，左右子树节点数是不变的，而后序遍历是左>右>中的顺序，所以直接按区间数就可以拆分后序遍历数组的左右子树区间。（前序遍历是一样的，中>左>右，从第二个元素开始取值就行）
- 第六步：分别拿到了中序和后序、中序和前序的左右子区间，就转化为子问题了，直接交给递归，然后将返回的子树接到root上，返回root即可。
- 在分割的时候，一定要✊左闭右开的原则（如果不用下标写，创建vector时vec.end()刚好是开区间

代码实现

后序遍历和中序遍历构造

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 delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

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

        // postorder 舍弃末尾元素
        postorder.resize(postorder.size() - 1);

        // 切割后序数组
        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

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

上面这个写法，在递归里创建了大量的vector，空间复杂度很高，可以改为下标法写。

// 不用数组递归，是因为需要频繁的创造子vector，导致空间复杂度很高
    TreeNode* traversal(vector<int>& inorder, vector<int>&postorder, 
        int inorder_begin, int inorder_end, int postorder_begin, int postorder_end) {
            if (postorder_end - postorder_begin == 0)    return nullptr;
            //拿到中间节点
            TreeNode* root = new TreeNode(postorder[postorder_end - 1]);

            //在中序数组中查找跟节点位置
            int root_index = 0;
            for (int index = inorder_begin; index < inorder_end; ++index) {
                if (inorder[index] == root->val) {
                    root_index = index;
                    break;
                }
            }

            //分割中序数组
            int inorder_left_begin = inorder_begin;
            int inorder_left_end = root_index;
            int inorder_right_begin = inorder_left_end + 1;
            int inorder_right_end = inorder_end;

            //分割后序数组
            int postorder_left_begin = postorder_begin;
            int postorder_left_end = postorder_begin + inorder_left_end - inorder_left_begin;
            int postorder_right_begin = postorder_left_end;
            int postorder_right_end = postorder_end - 1;

            root->left = traversal(inorder, postorder, inorder_left_begin, inorder_left_end, postorder_left_begin, postorder_left_end);
            root->right = traversal(inorder, postorder, inorder_right_begin, inorder_right_end, postorder_right_begin, postorder_right_end);
            return root;
        }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.empty())  return nullptr;
        return traversal(inorder, postorder, 0, inorder.size(), 0, postorder.size());
    }

前序遍历和中序遍历构造

TreeNode* traversal(vector<int>& preorder, vector<int>& inorder, int preorder_begin, int preorder_end, int inorder_begin, int inorder_end) {
        if (preorder_begin == preorder_end) return nullptr;
        TreeNode* root = new TreeNode(preorder[preorder_begin]);
        if (preorder_end - preorder_begin == 1)  return root;

        int root_index = inorder_begin;
        for(root_index; root_index < inorder_end; ++root_index) {
            if (inorder[root_index] == root->val)   break;
        }
        //切割中序数组
        int inorder_left_begin = inorder_begin;
        int inorder_left_end = root_index;
        int inorder_right_begin = inorder_left_end + 1;
        int inorder_right_end = inorder_end;

        //切割前序数组
        int preorder_left_begin = preorder_begin + 1;
        int preorder_left_end = preorder_begin + 1 + inorder_left_end - inorder_left_begin;
        int preorder_right_begin = preorder_left_end;
        int preorder_right_end = preorder_end;

        //递归
        root->left = traversal(preorder, inorder, preorder_left_begin, preorder_left_end, inorder_left_begin, inorder_left_end);
        root->right = traversal(preorder, inorder, preorder_right_begin, preorder_right_end, inorder_right_begin, inorder_right_end);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.empty() || inorder.empty())    return nullptr;
        return traversal(preorder, inorder, 0, preorder.size(), 0, inorder.size());
    }