513.找树左下角的值
给定一个二叉树的 根节点 root
,请找出该二叉树的 最底层 最左边 节点的值。
/**
* 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 findBottomLeftValue(TreeNode* root) {
queue<TreeNode*> s;
vector<int> v,res;
int num = 1;
s.push(root);
while(!s.empty())
{
v.push_back(s.front()->val);
if(s.front()->left) s.push(s.front()->left);
if(s.front()->right) s.push(s.front()->right);
s.pop();
num--;
if(!num)
{
num = s.size();
res = v;
v.clear();
}
}
return res[0];
}
};
112. 路径总和
给你二叉树的根节点 root
和一个表示目标和的整数 targetSum
。判断该树中是否存在 根节点到叶子节点 的路径,这条路径上所有节点值相加等于目标和 targetSum
。如果存在,返回 true
;否则,返回 false
。
/**
* 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:
void getSum(TreeNode* T,int sum,vector<int>& v)
{
if(T->left == NULL && T->right == NULL)
{
sum += T->val;
v.push_back(sum);
return;
}
sum += T->val;
if(T->left)getSum(T->left,sum,v);
if(T->right)getSum(T->right,sum,v);
}
bool hasPathSum(TreeNode* root, int targetSum) {
if(root == NULL) return false;
vector<int> v;
int sum = 0;
getSum(root,sum,v);
for(int i = 0;i<v.size();i++)
{
if(v[i] == targetSum) return true;
}
return false;
}
};
106.从中序与后序遍历序列构造二叉树
给定两个整数数组 inorder
和 postorder
,其中 inorder
是二叉树的中序遍历, postorder
是同一棵树的后序遍历,请你构造并返回这颗 二叉树 。
自己的错误思路:通过找到节点的迭代器来进行数组切割,但是中序(左中右)后序遍历(左右中)虽然都是第一个元素是左,但是其分别代表的是子树,所以通过这个进行切割就会丢元素(丢掉左节点的左节点),因此不正确。如下(最好不看,扰乱思路)
/**
* 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* sbuTree(vector<int> inorder, vector<int> postorder)
{
if(postorder.empty() || inorder.empty()) return NULL;
TreeNode* T = new TreeNode(postorder[postorder.size()-1]);
if (postorder.size() == 1) return T;
vector<int>::iterator it = find(inorder.begin(), inorder.end(), postorder[postorder.size()-1]);
//cout<<*it<<endl;
vector<int> inleft,inright,postleft,postright;
inleft.assign(inorder.begin(),it);
inright.assign(it+1,inorder.end());
if(!inright.empty())
{
vector<int>::iterator iit = find(postorder.begin(), postorder.end()-1, inright[0]);
postleft.assign(postorder.begin(),iit+1);
postright.assign(iit+1,postorder.end()-1);
}
else if(inright.empty())
{
postleft.assign(postorder.begin(),postorder.end()-1);
//postright.assign(iit,postorder.end()-1);
}
T->left = sbuTree(inleft,postleft);//null 3
T->right = sbuTree(inright,postright);//23 2
return T;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
return sbuTree(inorder,postorder);
}
};
正确思路:根据左右子树的个数来进行切割,代码来源:代码随想录 (programmercarl.com)
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;
}
// 切割中序数组
// 左闭右开区间:[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);
}
};