二叉树与递归 LeetCode 104&111&226&100&101&222&110&112&404&257&113&129&437&235&98

思路：

一棵二叉树的最高深度是等于其左子树和右子树的最高深度的最大值+1

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == NULL)
        {
            return 0;
        }
        int lDepth = maxDepth(root->left);//左子树的最大深度
        int rDepth = maxDepth(root->right);//右子树的最大深度
        return max(lDepth,rDepth)+1; 
    }
};

思路：

这道题不可以按照求最大值一样，直接求两棵子树的最小值，作为答案。

值得注意的一种情况是，如果根节点的左右两个孩子有一个为空，直接取最小，则取值为0，那么该层的深度计算就不正确了，则不满足题意。

代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==NULL)
            return 0;
        //要注意如果根节点的左或右子树为空的话是构不成子树的。
        if(root->right==NULL && root->left!=NULL)
            return minDepth(root->left)+1;
        if(root->right!=NULL && root->left==NULL) 
            return minDepth(root->right)+1;
        int lDepth = minDepth(root->left);//左子树的最小深度
        int rDepth = minDepth(root->right);//右子树的最小深度
        return min(lDepth,rDepth)+1; 
    }
};

思路：

递归交换左子树和右子树

代码：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
		if(root==NULL)
			return NULL;
		TreeNode* left = invertTree(root->left);//翻转完左子树后的结果
		TreeNode* right = invertTree(root->right);//翻转完右子树后的结果
		root->left=right;
		root->right=left;
		return root; 
    }
};

思路：

先判断当前的p,q是否相同，然后递归判断他们的左子树是否相同；右子树是否相同

代码：

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p==NULL && q==NULL)
            return true;
        if(p==NULL && q!=NULL)
            return false;
        if(p!=NULL && q==NULL)
            return false;
        if(p->val!=q->val)
            return false;
        bool l=isSameTree(p->left,q->left);//比较左子树是否相同 
        bool r=isSameTree(p->right,q->right);//比较右子树是否相同 
        return l&&r; 
    }
};

思路：

写一个函数判断两棵树是否对称。

1.要求两个树的当前结点的数值相同

2.第一棵树的左子树与第二棵树的右子树相同

3.第一棵树的右子树与第二棵树的左子树相同

代码：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
         return isMirror(root, root);
    }
     //判断两棵子树是否对称 
    bool isMirror(TreeNode* t1,TreeNode* t2) {
        if(t1==NULL && t2==NULL)
            return true;
        if(t1==NULL || t2==NULL)
            return false;
     //它们的两个根结点具有相同的值。
        if(t1->val!=t2->val)
            return false;
     //每个树的右子树都与另一个树的左子树镜像对称。
        return  isMirror(t1->left,t2->right) &&  isMirror(t1->right,t2->left); 
         
    } 
};

思路：节点数=左子树结点+右子树结点+1

代码：

class Solution {
public:
    int countNodes(TreeNode* root) {
    	if(root==NULL)
    		return 0;
    	return countNodes(root->left)+countNodes(root->right) +1;
    }
};

思路：

1.写一个函数，计算以root为节点的树的高度

2.比较当前节点左右两棵子树的高度，相差大于1，则返回false

3.递归比较所有子树

代码：

class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if(root==NULL)
            return true;
        int lHeight = height(root->left);
        int rHeight = height(root->right);
        if(abs(lHeight-rHeight)>1 ) 
            return false;
        return isBalanced(root->left) && isBalanced(root->right);
     }
    //计算以root为根节点的树的高度 
    int height(TreeNode* root)
    {
        if(root==NULL)
            return 0;
        return max(height(root->left),height(root->right))+1; 
    }
};

思路：

要注意的是，找到的路径的最后一个结点必须是叶子节点

所以就是一直递归找到叶子节点，并且sum的值减去从根节点到这个节点的所有值，看这个叶子节点是否等于sum值

代码：

class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
    	if(root==NULL)
			return false; 
		if(root->left==NULL && root->right==NULL) //找到当叶子节点
			return root->val==sum;
		return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val);
    }
};

思路：

定义一个全局遍历存储结果。

如果当前节点的左孩子是叶子节点，将左孩子的值加到结果上。

递归遍历左子树和右子树

代码：

class Solution {
public:
	int result=0;
    int sumOfLeftLeaves(TreeNode* root) {
		if(root==NULL)
			return 0;
		//判断当前节点的左孩子是否为目标节点 
		if(root->left!=NULL && root->left->left==NULL && root->left->right==NULL)
		 	result+=root->left->val;
		
		sumOfLeftLeaves(root->left);
		sumOfLeftLeaves(root->right);
		return result;
    }
};

思路：

获取左右子树的全部路径，将结果为当前node->左右子树路径

代码：

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
    	vector<string> res;
		if(root==NULL)
			return res;
		if(root->left==NULL && root->right==NULL)//当前节点是叶子节点
		{
			res.push_back(to_string(root->val));
			return res;
		} 
		vector lres=binaryTreePaths(root->left); //获取左子树全部路径 
		vector rres=binaryTreePaths(root->right);//获取右子树全部路径
		for(int i=0; i<lres.size(); i++)
			res.push_back(to_string(root->val)+"->"+lres[i]);
		for(int i=0; i<rres.size(); i++)
			res.push_back(to_string(root->val)+"->"+rres[i]); 
		return res;	
    }
};

思路：

获取左右子树满足sum-root->val的路径，并且拼接结果

代码：

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
    	vector<vector<int>> res;
    	if(root==NULL)
			return res;
		if(root->left==NULL && root->right==NULL) //当前节点就是叶子节点
		{
			if(root->val==sum)//满足题意 
			{
				vector<int> r;
				r.push_back(root->val);
				res.push_back(r);
				return res; 
			} 
		}
		vector<vector<int>> lres = pathSum(root->left, sum-root->val);   
		vector<vector<int>> rres = pathSum(root->right, sum-root->val);   
		for(int i=0; i<lres.size(); i++)
		{
			vector<int> r;
			r.push_back(root->val);
			for(int j=0; j<lres[i].size(); j++)
			{
				r.push_back(lres[i][j]);
			}
			res.push_back(r);
		}
		for(int i=0; i<rres.size(); i++)
		{
			vector<int> r;
			r.push_back(root->val);
			for(int j=0; j<rres[i].size(); j++)
			{
				r.push_back(rres[i][j]);
			}
			res.push_back(r);
		}
		return res;
    }
};

思路：写一个函数获取从root到叶子节点的全部路径vector<vector<int>>

按照路径拼接结果

代码：

/**
	求根到叶子节点数字之和
**/
class Solution {
public:
    int sumNumbers(TreeNode* root) {
		if(root==NULL)
			return 0;
		vector<vector<int>> res =  path(root);
		int ans=0;
		
		for(int i=0; i<res.size(); i++)
		{
			int sum = 0;
			for(int j=0; j<res[i].size(); j++)	
			{
				sum=sum*10+res[i][j];
			}
			ans += sum;
		}
		return ans;
    }
    //获取以root为根节点的全部路径
	vector<vector<int>> path(TreeNode* root) {
    	vector<vector<int>> res;
    	if(root==NULL)
			return res;
		if(root->left==NULL && root->right==NULL) //当前节点就是叶子节点
		{
			vector<int> r;
			r.push_back(root->val);
			res.push_back(r);
			return res; 
		}
		vector<vector<int>> lres = path(root->left);   
		vector<vector<int>> rres = path(root->right);   
		for(int i=0; i<lres.size(); i++)
		{
			vector<int> r;
			r.push_back(root->val);
			for(int j=0; j<lres[i].size(); j++)
			{
				r.push_back(lres[i][j]);
			}
			res.push_back(r);
		}
		for(int i=0; i<rres.size(); i++)
		{
			vector<int> r;
			r.push_back(root->val);
			for(int j=0; j<rres[i].size(); j++)
			{
				r.push_back(rres[i][j]);
			}
			res.push_back(r);
		}
		return res;
    }
};

思路：

解决这道题，分两个情况讨论，一个情况是node在这个路径上；一个是node不在这个路径上。

代码：

class Solution {
public:
    int pathSum(TreeNode* root, int sum) {
		if(root==NULL)
			return 0;
		//结果由3个部分组成，路径包含node节点，不包含node节点的 
		int res=0;
		res+=findPath(root,sum);
		res+=pathSum(root->left,sum);
		res+=pathSum(root->right,sum);
		return res;
    }
    //在以node为根节点的二叉树中，寻找包含node节点，和为sum的路径数
	//路径的终点不一定为叶子节点 
    int findPath(TreeNode* root, int sum){
    	if(root==NULL)
    		return 0;
    	int res= 0 ;
    	if( root->val == sum)
    		res+=1;
		 
    	return res + findPath(root->left,sum-root->val) + findPath(root->right,sum-root->val);
		 
    }
};

思路：

思路：如果p.q是小于node,就在node的右子树上寻找p,q的公共祖先；

如果p.q是大于node,就在node的左子树上寻找p,q的公共祖先；

node就是p,q的最近公共祖先的情况:

1.一个小于node，一个大于node

2.p或者q的值等于node

代码：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==NULL)
        	return NULL;
        //p,q小于root 最近祖先在左子树上
        if(p->val<root->val && q->val<root->val) 
        	return lowestCommonAncestor(root->left,p,q);
		//p,q大于root 最近祖先在右子树上
		if(p->val>root->val && q->val>root->val) 
        	return lowestCommonAncestor(root->right,p,q);
		//p/q==root,或者p,q一大一小 最近祖先就是root 
        return root;
    }
};

class Solution {
public:
	vector<int> vec;
    bool isValidBST(TreeNode* root) {
        //中序遍历，必须是从小到大，否则非二叉搜索树
		InOrder(root);
		for(int i=1; i<vec.size(); i++)
		{
			if(vec[i]<=vec[i-1])
				return false;
		}
		return true;
    }
    void InOrder(TreeNode* root)
    {
    	if(root!=NULL)
    	{
    		InOrder(root->left);
    		vec.push_back(root->val);
    		InOrder(root->right);
    	}
    }
    
};