513.找树左下角的值
层序遍历,找到最后一层的第一个值。
/**
* 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) {
if(root==NULL) return 0;
queue<TreeNode*> que;
que.push(root);
int ans=0;
while(!que.empty()){
int size = que.size();
for(int i=0; i<size; i++){
TreeNode* cur = que.front();
que.pop();
if(i==0) ans = cur->val;
if(cur->left) que.push(cur->left);
if(cur->right) que.push(cur->right);
}
}
return ans;
}
};
112. 路径总和
/**
* 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:
bool traversal(TreeNode* root, int targetSum){
if(root->left==NULL && root->right==NULL
&& targetSum==0) return true;
if(root->left==NULL && root->right==NULL
&& targetSum!=0) return false;
if(root->left){
targetSum -= root->left->val;
if(traversal(root->left, targetSum)) return true;
targetSum += root->left->val;
}
if(root->right){
targetSum -= root->right->val;
if(traversal(root->right, targetSum)) return true;
targetSum += root->right->val;
}
return false;
}
bool hasPathSum(TreeNode* root, int targetSum) {
if(root==NULL) return false;
return traversal(root, targetSum-root->val);
}
};
113.路径总和ii
/**
* 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 traversal(TreeNode* node, int targetSum, vector<int>& path, vector<vector<int>>& ans){
if(node->left==NULL && node->right==NULL && targetSum==0) {
ans.push_back(path);
return;
}
if(node->left){
path.push_back(node->left->val);
targetSum -= node->left->val;
traversal(node->left, targetSum, path, ans);
targetSum += node->left->val;
path.pop_back();
}
if(node->right){
path.push_back(node->right->val);
targetSum -= node->right->val;
traversal(node->right, targetSum, path, ans);
targetSum += node->right->val;
path.pop_back();
}
return;
}
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
vector<int> path;
vector<vector<int>> ans;
if(root==NULL) return ans;
path.push_back(root->val);
traversal(root, targetSum-root->val, path, ans);
return ans;
}
};
106.从中序与后序遍历序列构造二叉树
-
第一步:如果数组大小为零的话,说明是空节点了。
-
第二步:如果不为空,那么取后序数组最后一个元素作为节点元素。
-
第三步:找到后序数组最后一个元素在中序数组的位置,作为切割点
-
第四步:切割中序数组,切成中序左数组和中序右数组 (顺序别搞反了,一定是先切中序数组)
-
第五步:切割后序数组,切成后序左数组和后序右数组
-
第六步:递归处理左区间和右区间
区间统一为左闭右开
/**
* 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* findroot(vector<int>& inorder, int inorderBegin,int inorderEnd,vector<int>& postorder,int postorderBegin,int postorderEnd) {
// 中序区间:[inorderBegin, inorderEnd),后序区间[postorderBegin, postorderEnd)
//空树
if(postorderBegin==postorderEnd) return NULL;
//通过后序最后一个元素找到根节点
int rootval = postorder[postorderEnd-1];
TreeNode* root = new TreeNode(rootval);
//只有一个根节点
if(postorderEnd-postorderBegin==1) return root;
//通过遍历找到根节点在前序中的位置 index标记
int index;
for(index=inorderBegin;index<inorderEnd;index++){
if(inorder[index]==rootval)break;
}
//先分割中序在分割后序 左闭右开
int leftinorderbeign = inorderBegin;
int leftinorderend = index;
int rightinorderbeign = index+1;
int rightinorderend = inorderEnd;
int leftpostorderbeign = postorderBegin;
int leftpostorderend = postorderBegin+index-leftinorderbeign;
int rightpostorderbeign = postorderBegin+index-leftinorderbeign;
int rightpostorderend = postorderEnd-1;
root->left = findroot(inorder,leftinorderbeign,leftinorderend,
postorder,leftpostorderbeign,leftpostorderend);
root->right = findroot(inorder,rightinorderbeign,rightinorderend,
postorder,rightpostorderbeign,rightpostorderend);
return root;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if (inorder.size() == 0 || postorder.size() == 0) return NULL;
return findroot(inorder,0,inorder.size(),postorder,0,postorder.size());
}
};
105.从前序与中序遍历序列构造二叉树
/**
* 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* findroot(vector<int>& inorder, int inorderBegin,int inorderEnd,vector<int>& preorder,int preorderBegin,int preorderEnd) {
// 中序区间:[inorderBegin, inorderEnd),前序区间[preorderBegin, preorderEnd)
//空树
if(preorderBegin==preorderEnd) return NULL;
//通过前序第一个元素找到根节点
int rootval = preorder[preorderBegin];
TreeNode* root = new TreeNode(rootval);
//只有一个根节点
if(preorderEnd-preorderBegin==1) return root;
//通过遍历找到根节点在前序中的位置 index标记
int index;
for(index=inorderBegin;index<inorderEnd;index++){
if(inorder[index]==rootval)break;
}
//先分割中序在分割后序 左闭右开
int leftinorderbeign = inorderBegin;
int leftinorderend = index;
int rightinorderbeign = index+1;
int rightinorderend = inorderEnd;
int leftpreorderbeign = preorderBegin+1;
int leftpreorderend = preorderBegin+1+index-leftinorderbeign;
int rightpreorderbeign = preorderBegin+1+index-leftinorderbeign;
int rightpreorderend = preorderEnd;
root->left = findroot(inorder,leftinorderbeign,leftinorderend,
preorder,leftpreorderbeign,leftpreorderend);
root->right = findroot(inorder,rightinorderbeign,rightinorderend,
preorder,rightpreorderbeign,rightpreorderend);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
if (inorder.size() == 0 || preorder.size() == 0) return NULL;
return findroot(inorder,0,inorder.size(),preorder,0,preorder.size());
}
};