513. 找树左下角的值
给定一个二叉树的 根节点 root
,请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。
示例 1:
输入: root = [2,1,3] 输出: 1
示例 2:
输入: [1,2,3,4,null,5,6,null,null,7] 输出: 7
思路:
这道有关二叉树的题目如果用递归的方法是有一定难度的,倒是用二叉树的层序遍历的话,题目会简单很多。
我们用层序遍历(如果不会层序遍历可以看我往期那篇有关二叉树层序遍历的文章),用result记录每一层的第一个值,随着层序遍历的结束,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;
}
};
112. 路径总和
给你二叉树的根节点 root
和一个表示目标和的整数 targetSum
。判断该树中是否存在 根节点到叶子节点 的路径,这条路径上所有节点值相加等于目标和 targetSum
。如果存在,返回 true
;否则,返回 false
。
叶子节点 是指没有子节点的节点。
示例 1:
输入:root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 输出:true 解释:等于目标和的根节点到叶节点路径如上图所示。
示例 2:
输入:root = [1,2,3], targetSum = 5 输出:false 解释:树中存在两条根节点到叶子节点的路径: (1 --> 2): 和为 3 (1 --> 3): 和为 4 不存在 sum = 5 的根节点到叶子节点的路径。
示例 3:
输入:root = [], targetSum = 0 输出:false 解释:由于树是空的,所以不存在根节点到叶子节点的路径。
思路:
这道题很好的体现了递归回溯。
这道题没有明确的遍历顺序,因为没有中的处理逻辑。
定义一个sum遍历二叉树,将遍历到的结点的值相加,如果到叶子结点,sum!+targetsum,则回溯,即减去最近一个二叉树的值,继续遍历。如此循环下去。
递归三部曲:
第一部:确定函数返回值和参数
bool equul(TreeNode*root,int targetSum)
第二部:确定递归的终止条件
if(root->left==NULL&&root->right==NULL&&sum==targetSum) return true;
第三部:写出一次递归的逻辑
if(root->left)
{
if( equul(root->left,targetSum)) return true;
sum-=root->left->val;
}
if(root->right)
{
if( equul(root->right,targetSum)) return true;
sum-=root->right->val;
}
代码
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int sum = 0;
bool equul(TreeNode*root,int targetSum)
{
sum += root->val;
//if(root==NULL) return false;
if(root->left==NULL&&root->right==NULL&&sum==targetSum) return true;
if(root->left)
{
if( equul(root->left,targetSum)) return true;
sum-=root->left->val;
}
if(root->right)
{
if( equul(root->right,targetSum)) return true;
sum-=root->right->val;
}
return false;
}
bool hasPathSum(TreeNode* root, int targetSum) {
if(root==NULL) return false;
bool ret = equul(root,targetSum);
cout<<sum<<endl;
return ret;
}
};
106. 从中序与后序遍历序列构造二叉树
给定两个整数数组 inorder
和 postorder
,其中 inorder
是二叉树的中序遍历, postorder
是同一棵树的后序遍历,请你构造并返回这颗 二叉树 。
示例 1:
输入:inorder = [9,3,15,20,7], postorder = [9,15,7,20,3] 输出:[3,9,20,null,null,15,7]
示例 2:
输入:inorder = [-1], postorder = [-1] 输出:[-1]
思路:
中序遍历是左中右,后序遍历是左右中
可以由后续遍历得到中,即根节点,由根节点可以将中序数组分成中序左,中序右两个数组。再由中序左这个数组把后续数组分成后续左,后续右。这里省略了一些代码细节,递归下去,就可以构造出二叉树。
-
第一步:如果数组大小为零的话,说明是空节点了。
-
第二步:如果不为空,那么取后序数组最后一个元素作为节点元素。
-
第三步:找到后序数组最后一个元素在中序数组的位置,作为切割点
-
第四步:切割中序数组,切成中序左数组和中序右数组 (顺序别搞反了,一定是先切中序数组)
-
第五步:切割后序数组,切成后序左数组和后序右数组
-
第六步:递归处理左区间和右区间
代码:
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
if(postorder.size()==0) return NULL;
TreeNode* root = new TreeNode(postorder[postorder.size()-1]);
if(postorder.size()==1) return root;
int delimiterIndex = 0;
for(int i = 0;i<inorder.size();i++)
{
if(inorder[i]==root->val)
{
delimiterIndex = i;
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;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
return traversal(inorder,postorder);
}
};
还有很多瑕疵,还需继续坚持!