#include <iostream>
#include <vector>
#include <queue>
using namespace std;
struct TreeNode
{
int val;
TreeNode* left,*right;
TreeNode(int x):val(x),left(NULL),right(NULL){}
};
/***************************************************
* 函数功能:Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.
* 参数说明
* 输入参数:Given the below binary tree and sum = 22,
5
/ \
4 8
/ / \
11 13 4
/ \ / \
7 2 5 1
* 输出参数:
[
[5,4,11,2],
[5,8,4,5]
]
* 复杂性分析:时间复杂度:O(),空间复杂度:O()
* 题目来源 :https://leetcode.com/problems/path-sum-ii/description/
* 日期:2018-07-22-21.19
***************************************************/
class Solution1
{
public:
vector<vector<int> > pathSum(TreeNode* root,int sum)
{
vector<int> item;
vector<vector<int> > result;
if(root==NULL) return result;
int target_sum=0;
pathSum(root,sum,item,result,target_sum);
return result;
}
private:
void pathSum(TreeNode* root,int sum,vector<int>& item,vector<vector<int> >& result,int target_sum)
{
if(root==NULL)
{
return ;
}
item.push_back(root->val);
target_sum+=root->val;
if(target_sum==sum && root->left==NULL && root->right==NULL)
{
result.push_back(item);
}
pathSum(root->left,sum,item,result,target_sum);
pathSum(root->right,sum,item,result,target_sum);
item.pop_back();
target_sum-=root->val;
}
};
/***************************************************
* 函数功能:236. Lowest Common Ancestor of a Binary Tree
* 参数说明
* 输入参数:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
* 输出参数:3 The LCA of of nodes 5 and 1 is 3.
* 复杂性分析:时间复杂度:O(),空间复杂度:O()
* 题目来源 :https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/
* 日期:2018-07-22-21.19
***************************************************/
class Solution2
{
public:
TreeNode* lowestCommonAncestor(TreeNode* root,TreeNode* p,TreeNode* q)
{
if(root==NULL || p==NULL || q==NULL)
{
return NULL;
}
vector<TreeNode*> item;
vector<TreeNode*> vec_p;
get_path(root,p,vec_p,item);
item.clear();
vector<TreeNode*> vec_q;
get_path(root,q,vec_q,item);
int length=vec_p.size()>vec_q.size()?vec_q.size():vec_p.size();
TreeNode* result=NULL;
for(int i=0;i<length;i++)
{
if(vec_p[i]==vec_q[i])
{
result=vec_p[i];
}else
{
break;
}
}
return result;
}
private:
void get_path(TreeNode* root,TreeNode* target,vector<TreeNode*>& result,vector<TreeNode*>& item)
{
if(root==NULL)
{
return ;
}
item.push_back(root);
if(root==target)
{
result=item;
return ;
}
get_path(root->left,target,result,item);
get_path(root->right,target,result,item);
item.pop_back();
}
};
/***************************************************
* 函数功能:Flatten Binary Tree to Linked List Given a binary tree, flatten it to a linked list in-place.
* 参数说明
* 输入参数:
1
/ \
2 5
/ \ \
3 4 6
* 输出参数:
1
\
2
\
3
\
4
\
5
\
6
* 复杂性分析:时间复杂度:O(),空间复杂度:O()
* 题目来源 : https://leetcode.com/problems/flatten-binary-tree-to-linked-list/description/
* 日期:2018-07-22-22.06
***************************************************/
class Solution3
{
public:
void flatten_new(TreeNode* root)
{
if(root==NULL) return ;
TreeNode* pre=NULL;
flatten_new(root,pre);
}
void flatten_new(TreeNode* root,TreeNode*& pre)
{
if(root==NULL)
{
return ;
}
flatten_new(root->right,pre);
flatten_new(root->left,pre);
root->right=pre;
root->left=NULL;
pre=root;
}
void flatten(TreeNode* root)
{
if(root==NULL) return ;
vector<TreeNode*> result;
flatten(root,result);
for(int i=1;i<result.size();i++)
{
result[i-1]->left=NULL;
result[i-1]->right=result[i];
}
}
private:
void flatten(TreeNode* root,vector<TreeNode*>& result)
{
if(root==NULL)
{
return ;
}
result.push_back(root);
flatten(root->left,result);
flatten(root->right,result);
}
};
void print_Tree(TreeNode* root,int layer)
{
if(root==NULL)
{
return ;
}
for(int i=0;i<layer;i++)
{
cout<<"--";
}
cout<<root->val<<endl;
print_Tree(root->left,layer+1);
print_Tree(root->right,layer+1);
}
/***************************************************
* 函数功能:Binary Tree Right Side View
* 参数说明
* 输入参数:[1,2,3,null,5,null,4]
1 <---
/ \
2 3 <---
\ \
5 4 <---
* 输出参数:[1, 3, 4]
* 复杂性分析:时间复杂度:O(),空间复杂度:O()
* 题目来源 : https://leetcode.com/problems/binary-tree-right-side-view/description/
* 日期:2018-07-23-08.46
***************************************************/
class Solution4
{
public:
vector<int> rightSideView(TreeNode* root)
{
vector<int> result;
if(root==NULL) return result;
queue<pair<TreeNode*,int> > Q;
Q.push(make_pair(root,1));
int level=0;
while(!Q.empty())
{
TreeNode* node=Q.front().first;
int deep=Q.front().second;
Q.pop();
if(deep!=level)
{
result.push_back(node->val);
level=deep;
}else
{
result[deep-1]=node->val;
}
if(node->left)
{
Q.push(make_pair(node->left,deep+1));
}
if(node->right)
{
Q.push(make_pair(node->right,deep+1));
}
}
return result;
}
};