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

最新推荐文章于 2024-05-20 20:08:58 发布

无言以对，沉默不语，随你随你。

最新推荐文章于 2024-05-20 20:08:58 发布

阅读量873

点赞数 22

文章标签：算法数据结构

本文链接：https://blog.csdn.net/WEnyue4261/article/details/135929546

版权

找树左下角的值

题目：给定一个二叉树，在树的最后一行找到最左边的值。

思路：1.层序遍历 2.递归

递归

找最后一行，最左边，深度最大的叶子节点。

最左边，左优先，保证优先左边搜索，记录深度最大的叶子节点，此时就是树的最后一行最左边的值。无中间节点的处理逻辑，可以使用前序遍历、也可以中后，左优先就可以。

递归三部曲：

1.确定递归函数的参数和返回值

参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。这里就不需要返回值了，所以递归函数的返回值类型为void.

本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。

代码如下：

int maxDepth = INT_MIN; //全局变量，记录最大深度
int result;//全局变量  最大深度最左节点的数值
void traversal(TreeNode* root,int depth)

2.确定终止条件

当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。

if(root->left == NULL && root->right == NULL){
    if(depth > maxDepth){
        maxDepth = depth;//更新最大深度
        result = root->val;//最大深度最左面的数值
    }
    return;
}

3.确定单层递归的逻辑

在找最大深度的时候，递归的过程中依然要使用回溯，代码如下：

if(root->left){
    depth++;
    traversal(root->left,depth);
    depth--;
}
if(root->right){
    depth++;  //深度加一
    traversal(root->right,depth);
    depth--;
}
return;

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 = depth;
            result = root->val;
        }
        return;
      }
      if(root->left){
        depth++;
        traversal(root->left,depth);
        depth--;
      }
      if(root->right){
        depth++;
        traversal(root->right,depth);
        depth--;
      }
      return;
   }
   int findBottomLeftValue(TreeNode* root){
    traversal(root,0);
    return result;
   }
};

回溯的地方精简一下

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 = depth;
         result = root->val;
       }
       return;
     }
     if(root->left){
       traversal(root->left,depth + 1);
     }
     if(root->right){
       traversal(root->right,depth + 1);
     }
     return;
   }
   int findBottomLeftValue(TreeNode* root){
     traversal(root,0);
     return result;
   }
   ;
}

迭代法

层序遍历，进行迭代

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

递归求深度，递归中隐藏了回溯，层序遍历

路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

存在就返回true

思路：

遍历从根节点到叶子节点的路径看看总和是不是目标和。

递归

可以使用深度优先遍历的方式，因为中节点没有处理逻辑，所以前中后序遍历都可以。

1.确定递归函数的参数和返回类型

参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。

返回值：

>>如果需要搜索整棵二叉树且不用处理递归函数返回值，递归函数就不要返回值。

>>如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。

>>如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。

这道题中，我们要找到其中一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？

遍历的路线，并不一定遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。

所以代码如下：

bool traversal(treenode* cur,int count)//注意函数的返回类型

2.确定终止条件

首先计数器如何统计这一条路径的和呢？

不去累加然后判断是否等于目标和，那么代码比较麻烦，可以用递减，让计数器count初始值为目标和，然后每次减去遍历路径节点上的数值。

如果最后count == 0，同时到了叶子节点的话，说明找到了目标和。

如果遍历到了叶子节点，count不为0，就是没找到。

递归终止条件代码如下：

if(!cur->left && !cur->right && count == 0)return true;//遇到叶子节点，并且计为0
if(!cur->left && !cur->right)return false;//遇到叶子节点而没有找到合适的边，直接返回

3.确定单层递归的逻辑

因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。

递归函数是有返回值的，如果递归函数返回true,说明找到了合适的路径，应该立刻返回。

代码如下：

if(cur->left){
  //遇到叶子节点返回true,则直接返回true
  if(traversal(cur->left,count - cur->left->val))return true;
}
if(cur -> right){
  if(traversal(cur->right,count - cur->right->val))return true;
}
return false;

以上代码是包含着回溯的，没有回溯，如何后撤重新找另一条路径呢？

回溯隐藏在traversal ( cur -> left, count - cur -> left -> val)这里，因为把 count - cur -> left -> val直接作为参数传进去，函数结束，count的数值没有改变。

为了把回溯的过程体现出来，可以改为如下代码：

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;

//整体代码
class Solution{
private:
    bool traversal(TreeNode* cur,int count){
      if(!cur->left && !cur->right && count == 0)return true;
      if(!cur -> left && !cur->right)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;
    }
    public:
      bool hasPathSum(TreeNode* root,int sum){
        if(root == NULL)return false;
        return traversal(root,sum - root ->val);
      }
};

//精简后
class Solution{
public:
  bool hasPathSum(TreNode* root,int sum){
    if(!root)return false;
    if(!root->left && !root->right && sum == root->val){
      return true;
    }
    return hasPathSum(root->left,sum - root->val)||hasPathSum(root->right,sum - root->val);
  }
};

迭代

如果使用栈模拟递归的话，那么如果做回溯呢？

此时栈里一个元素不仅要记录该节点指针，还要记录从头节点到该节点的路径数值总和。

C++中用pair结构来存放这个栈里的元素。

定义为： pair<TreeNode* ,int> pair<节点指针，路径数值>

这个为栈里的一个元素。

//使用栈模拟，前序遍历
class Solution{

public:
   bool hasPathSum(TreeNode* root,int sum){
     if(root == null)return false;

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

       }

     }
     return false;
   }
};

构造二叉树

题目：根据一棵树的中序遍历与后序遍历构造二叉树。

假设树中没有重复的元素。

思路：以后序数组的最后一个元素为分割点，先切中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

class Solution {
private:
    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;
        }

        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());

        // 以下为日志
        cout << "----------" << endl;

        cout << "leftInorder :";
        for (int i : leftInorder) {
            cout << i << " ";
        }
        cout << endl;

        cout << "rightInorder :";
        for (int i : rightInorder) {
            cout << i << " ";
        }
        cout << endl;

        cout << "leftPostorder :";
        for (int i : leftPostorder) {
            cout << i << " ";
        }
        cout << endl;
         cout << "rightPostorder :";
        for (int i : rightPostorder) {
            cout << i << " ";
        }
        cout << endl;

        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);
    }
};

无言以对，沉默不语，随你随你。

关注

22
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营Day18|找树左下角的值、路径总和、从中序与后序遍历序列构造二叉树

最左边，左优先，保证优先左边搜索，记录深度最大的叶子节点，此时就是树的最后一行最左边的值。无中间节点的处理逻辑，可以使用前序遍历、也可以中后，左优先就可以。不去累加然后判断是否等于目标和，那么代码比较麻烦，可以用递减，让计数器count初始值为目标和，然后每次减去遍历路径节点上的数值。参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。这道题中，我们要找到其中一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？
复制链接

扫一扫