Leetcode113深度搜索-路径之和
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
class Solution {
public:
vector<vector<int>> pathSum(TreeNode* root, int sum) {
std::vector<std::vector<int>>result;
std::vector<int>path;
int path_value=0;
preorder(root,path_value,sum,path,result);
return result;
}
private:
void preorder(TreeNode *node,int &path_value,int sum,std::vector<int>&path,
std::vector<std::vector<int>>&result){
if(!node)return;
path_value+=node->val;
path.push_back(node->val);
if(!node->left&&!node->right&&sum==path_value){
result.push_back(path);
}
preorder(node->left,path_value,sum,path,result);
preorder(node->right,path_value,sum,path,result);
path_value-=node->val;
path.pop_back();
}
};
Leetcode236 最近的公共祖先
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
std::vector<TreeNode* >path;
std::vector<TreeNode* >node_p_path;
std::vector<TreeNode* >node_q_path;
int finish=0;
preorder(root,p,path,node_p_path,finish);
path.clear();
finish=0;
preorder(root,q,path,node_q_path,finish);
int path_len=0;
if(node_q_path.size()<node_p_path.size()){
path_len=node_q_path.size();
}
else{
path_len=node_p_path.size();
}
TreeNode *result=0;
for(int i=0;i<path_len;i++){
if(node_q_path[i]==node_p_path[i]){
result=node_p_path[i];
}
}
return result;
}
private:
void preorder(TreeNode* node,TreeNode *search,
std::vector<TreeNode*>&path,
std::vector<TreeNode*>&result,
int &finish){
if(!node||finish){
return;
}
path.push_back(node);
if(node==search){
finish=1;
result=path;
}
preorder(node->left,search,path,result,finish);
preorder(node->right,search,path,result,finish);
path.pop_back();
}
};
Leetcode 114二叉树转链表
- 方法一(不就地)
class Solution {
public:
void flatten(TreeNode* root) {
std::vector<TreeNode*>node_vec;
preorder(root,node_vec);
for(int i=1;i<node_vec.size();i++){
node_vec[i-1]->right=node_vec[i];
node_vec[i-1]->left=NULL;
}
}
private:
void preorder(TreeNode *node,std::vector<TreeNode*>node_vec){
if(!node)return;
node_vec.push_back(node);
preorder(node->left,node_vec);
preorder(node->right,node_vec);
}
};
- 方法二(就地)递归
class Solution {
public:
void flatten(TreeNode* root) {
TreeNode* last=NULL;
preorder(root,last);
}
private:
void preorder(TreeNode *node,TreeNode *&last){
if(!node)return;
if(!node->left&&!node->right){
last=node;
return;
}
TreeNode *left=node->left;
TreeNode *right=node->right;
TreeNode *left_last=NULL;
TreeNode *right_last=NULL;\
if(left){
preorder(node->left,left_last);
node->left=NULL;
node->right=left;
last=left_last;
}
if(right){
preorder(node->right,right_last);
if(left_last){
left_last->right=right;
}
last=right_last;
}
}
};
Leetcode199从右侧观察二叉树
层次遍历二叉树每层最后一个节点
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
std::vector<int>view;
std::queue<std::pair<TreeNode*,int>>Q;
if(root){
Q.push(std::make_pair(root,0));
}
while(!Q.empty()){
TreeNode *node=Q.front().first;
int depth=Q.front().second;
Q.pop();
if(depth==view.size()){
view.push_back(node->val);
}else{
view[depth]=node->val;
}
if(node->left){
Q.push(std::make_pair(node->left,depth+1));
}
if(node->right){
Q.push(std::make_pair(node->right,depth+1));
}
}
return view;
}
};