调用level会遍历一遍所有的子节点,原因在于level没有记忆性,当输入为同一个节点时,level进行完整的计算
一种改进方法,可以考虑利用动态规划的思想,将TreeNode指针作为键,高度作为值,一旦发现节点已经被计算过,直接返回结果,这样level函数对每个节点只计算一次,另一种更为巧妙地方法是,isBalanced返回当前节点的高度,用-1表示树不平衡,将结果自底向上传递,并且确保每个节点只被计算一次复杂度O(n)
获取一个二叉树的路径,其和等于一个给定的值
反向搜索,找到和为满足的开始点。
一种改进方法,可以考虑利用动态规划的思想,将TreeNode指针作为键,高度作为值,一旦发现节点已经被计算过,直接返回结果,这样level函数对每个节点只计算一次,另一种更为巧妙地方法是,isBalanced返回当前节点的高度,用-1表示树不平衡,将结果自底向上传递,并且确保每个节点只被计算一次复杂度O(n)
int isBalancedHelper(TreeNode * root){
if(root==NULL){
return 0;
}
int left Height = isBalanced(root->left);
if(leftHeight== -1){
return -1;
}
int rightHeight = isBalanced(root->right);
if(rightHeight==-1){
return -1;
}
if(abs(leftHeight-rightHeight)>1){
return -1;
}
return max(leftHeight,rightHeight)+1;
}
bool isBalanced(TreeNode *root){
if(isBalancedHelper(root)==-1){
return -1;
}else{
return 1;
}
}
判断一颗二叉树是否是二叉搜索树
bool helper(TreeNode *root,int min,int max){
if(!root)
return true;
if((root->val<min || (root->val==INT_MAX && root->right == NULL))
&& (root->val > min || (root->val == INT_MIN &&root->left==NULL))
&& helper(root->left,min,root->val) &&
helpfer(root->right,root->val,max))
return 1;
return false;
}
bool isValidBST(TreeNode * root){
return helper(root,INT_MIN,INT_MAX);
}
判断2是否是1的子树
bool subTree(TreeNode *root1,TreeNode *root2){
if(root2 ==NULL){
return true;
}
if(root1==NULL){
return false;
}
if(root->val==root2->val){
if(match(root1,root2){
return true;
}
}
return isSubTree(root1->left,root2) || isSubTree(root1->right,root2);
}
bool match(TreeNode *root1,TreeNode *root2){
if(root1==NULL&&root2==NULL){
return true;
}
if(root1==NULL||root2==NULL){
return false;
}
if(root1->val!=root2->val){
return false;
}
return match(root1->left,root2->left)&&match(root1->right,root2->right);
}
获取一个二叉树的路径,其和等于一个给定的值
void pathSumHelper(vector<int> path,vector<vector<int>> &answer,TreeNode * root,int sum){
if(root==NULL)
return;
path.push_back(root->val);
if(root->val==sum)
answer.push_back(path);
pathSumHelper(path,answer,root-left,sum-root->val);
pathSumHelper(path,answer,root->right,sum-root->val);
}
vector<vector<int>> pathSum(TreeNode*root,int sum){
vector<int> path;
vector<vector<int>> result;
pathSumHelper(path,result,root,sum);
return result;
}
变形1 获取一个二叉树中的所有路径,总是从根和叶子的末端开始,路径之和等于一个给定的值
void pathSumHelper(vector<int> path,vector<vector<int>> &answer,TreeNode * root,int sum){
if(root==NULL)
return;
path.push_back(root->val);
//if(root->val==sum)
//这里相比前一道题目做了修改
if(root->left==NULL&&root->right==NULL&&root->val==sum){
answer.push_back(path);
}
pathSumHelper(path,answer,root-left,sum-root->val);
pathSumHelper(path,answer,root->right,sum-root->val);
//这里加一句
path.pop_back();
}
vector<vector<int>> pathSum(TreeNode*root,int sum){
vector<int> path;
vector<vector<int>> result;
pathSumHelper(path,result,root,sum);
return result;
}
反向搜索,找到和为满足的开始点。
void pathSumHelper(vector<int> path,vector<vector<int>> &answer,
TreeNode *root,int sum){
if(root==NULL)
return ;
path.push_back(root->val);
int tempSum = sum;
vector<int> partialPath;
for(int i =(int)path.size()-1;i>=0;i--){
tempSum -=path[i];
partialPath.push_back(path[i]);
if(tempSum ==0 ){
answer.push_back(partialPath);
}
}
pathSumHelper(path,answer,root->left,sum);
pathSumHelper(path,answer,root->right,sum-root->val);
}
vector<vector<int>> pathSum(TreeNode*root,int sum){
vector<int> path;
vector<vector<int>> result;
pathSumHelper(path,result,root,sum);
return result;
}