给你一棵所有节点为非负值的二叉搜索树,请你计算树中任意两节点的差的绝对值的最小值。
示例:
输入:
输出: 1
解释: 最小绝对差为 1,其中 2 和 1 的差的绝对值为 1(或者 2 和 3)。
提示:
树中至少有 2 个节点。
本题与 783 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ 相同
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:
题中所给的是所有节点为非负值的二叉搜索树,根据中序遍历得到升序的数组的特性,可以想象成是求一个数组中,先求任意两个元素之差的绝对值,然后再求最小值。由于这个数组是个升序的数组,只需要遍历一遍就能完成,因为只需要看相邻的两个元素之差,然后从中获取最小值即可。
如下图所示:
题解代码(C++):
/**
* 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:
int res = INT_MAX;
void dfs(TreeNode* root,TreeNode*& pre){
if(root==NULL) return;
dfs(root->left,pre);
if(pre==NULL) {
pre = root;
}else{
if(res>abs(root->val-pre->val))
res = abs(root->val-pre->val);
pre = root;
}
dfs(root->right,pre);
}
int getMinimumDifference(TreeNode* root) {
this->res = INT_MAX;
TreeNode* pre = NULL;
dfs(root,pre);
return this->res;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int res = Integer.MAX_VALUE;
public TreeNode pre = null;
public void dfs(TreeNode root,TreeNode pre){
if(root==null) return;
dfs(root.left,this.pre);
if(this.pre==null) this.pre = root;
else{
if(this.res>Math.abs(root.val-this.pre.val))
this.res = Math.abs(root.val-this.pre.val);
this.pre = root;
}
dfs(root.right,this.pre);
}
public int getMinimumDifference(TreeNode root) {
this.pre = null;
dfs(root,pre);
return this.res;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.res = pow(2,32)-1
self.pre = None
def dfs(self,root:TreeNode,pre:TreeNode):
if root is None:
return None
self.dfs(root.left,self.pre)
if self.pre is None:
self.pre = root
else:
if self.res > abs(root.val-self.pre.val):
self.res = abs(root.val-self.pre.val)
self.pre = root
self.dfs(root.right,self.pre)
def getMinimumDifference(self, root: TreeNode) -> int:
self.res = pow(2,32)-1
self.pre = None
self.dfs(root,self.pre)
return self.res
给定一个二叉搜索树和一个目标结果,如果 BST 中存在两个元素且它们的和等于给定的目标结果,则返回 true。
案例 1:
输入:
Target = 9
输出: True
案例 2:
输入:
Target = 28输出: False
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/two-sum-iv-input-is-a-bst
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:
在二叉树中判断是否存在两个元素之和等于Target的问题,不管是数组还是二叉树,都是遍历的问题,都可以借助map来保存临时结果,加速查找,本题较简单。
题解代码(C++):
/**
* 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:
map<int,int> mymap;
bool isFind = false;
void dfs(TreeNode* root,int k){
if(root==NULL || isFind) return;
dfs(root->left,k);
if(this->mymap.find(root->val)!=this->mymap.end()) {
this->isFind = true;
}else{
this->mymap[k-root->val] = 1;
}
dfs(root->right,k);
}
bool findTarget(TreeNode* root, int k) {
this->isFind = false;
this->mymap.clear();
dfs(root,k);
return this->isFind;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
HashMap<Integer,Integer> mymap = new HashMap<>();
boolean isFind = false;
public void dfs(TreeNode root,int k){
if(root==null || isFind) return;
dfs(root.left,k);
if(this.mymap.containsKey(root.val)){
this.isFind = true;
}else{
this.mymap.put(k-root.val,1);
}
dfs(root.right,k);
}
public boolean findTarget(TreeNode root, int k) {
this.isFind = false;
this.mymap.clear();
dfs(root,k);
return this.isFind;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.isFind = False
self.mymap = {}
def dfs(self,root:TreeNode,k: int):
if root is None or self.isFind :
return None
self.dfs(root.left,k)
if self.mymap.get(root.val):
self.isFind = True
else:
self.mymap[k-root.val] = 1
self.dfs(root.right,k)
def findTarget(self, root: TreeNode, k: int) -> bool:
self.isFind = False
self.mymap = {}
self.dfs(root,k)
return self.isFind
给定一个二叉树,它的每个结点都存放着一个整数值。
找出路径和等于给定数值的路径总数。
路径不需要从根节点开始,也不需要在叶子节点结束,但是路径方向必须是向下的(只能从父节点到子节点)。
二叉树不超过1000个节点,且节点数值范围是 [-1000000,1000000] 的整数。
示例:
root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 810 / \ 5 -3 / \ \ 3 2 11 / \ \ 3 -2 1
返回 3。和等于 8 的路径有:
- 5 -> 3
- 5 -> 2 -> 1
- -3 -> 11
来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/path-sum-iii
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:路径不需要从根节点开始,也不需要在叶子节点结束,暗示了需要以任意一个结点为根节点,开始树的遍历得到路径,再比较路径值是否等于sum,如果是结果加一,所以就是用双嵌套递归。
题解代码(C++):
/**
* 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:
int res = 0;
void dfs(TreeNode* root,int pre,int &sum){
if(root==NULL) return;
pre+=root->val;
if(pre==sum){
this->res++;
}
dfs(root->left,pre,sum);
dfs(root->right,pre,sum);
}
void traversal(TreeNode* root,int &sum){
if(root==NULL) return;
dfs(root,0,sum);
traversal(root->left,sum);
traversal(root->right,sum);
}
int pathSum(TreeNode* root, int sum) {
this->res = 0;
traversal(root,sum);
return this->res;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
int res = 0;
public void dfs(TreeNode root,int pre,int sum){
if(root ==null) return;
pre += root.val;
if(pre==sum)
this.res++;
dfs(root.left,pre,sum);
dfs(root.right,pre,sum);
}
public void traversal(TreeNode root,int sum){
if(root==null) return;
dfs(root,0,sum);
traversal(root.left,sum);
traversal(root.right,sum);
}
public int pathSum(TreeNode root, int sum) {
this.res = 0;
traversal(root,sum);
return res;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.res = 0
def dfs(self,root:TreeNode,pre:int,sum_:int):
if root is None:
return None
pre += root.val
if(pre==sum_):
self.res+=1
self.dfs(root.left,pre,sum_)
self.dfs(root.right,pre,sum_)
def traversal(self,root:TreeNode,sum_:int):
if root is None:
return None
self.dfs(root,0,sum_)
self.traversal(root.left,sum_)
self.traversal(root.right,sum_)
def pathSum(self, root: TreeNode, sum_: int) -> int:
self.res = 0
self.traversal(root,sum_)
return self.res
给定一个二叉树,计算整个树的坡度。
一个树的节点的坡度定义即为,该节点左子树的结点之和和右子树结点之和的差的绝对值。空结点的的坡度是0。
整个树的坡度就是其所有节点的坡度之和。
示例:
输入:1 / \ 2 3
输出: 1
解释: 结点的坡度 2 : 0 结点的坡度 3 : 0 结点的坡度 1 : |2-3| = 1 树的坡度 : 0 + 0 + 1 = 1
注意:
任何子树的结点的和不会超过32位整数的范围。 坡度的值不会超过32位整数的范围。来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/binary-tree-tilt
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:一个树的节点的坡度定义即为,该节点左子树的结点之和和右子树结点之和的差的绝对值。空结点的的坡度是0。
使用递归,边计算子树结点之和,边计算坡度即可。
简单框架:(获取树的结点值总和)
int getTreeSum(TreeNode* root,int sum){
if(root==NULL) return 0;
int leftSum = getTreeSum(root->left);
int rightSum=getTreeSum(root->right);
//已知左右子树结点总和,计算坡度小菜一碟
return leftSum+rightSum+root->val;
}
题解代码(C++):
/**
* 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:
int res = 0;
int getTreeSum(TreeNode* root){
if(root==NULL) return 0;
int leftSum = getTreeSum(root->left);
int rightSum = getTreeSum(root->right);
this->res += abs(leftSum-rightSum);
return root->val+leftSum+rightSum;
}
int findTilt(TreeNode* root) {
this->res = 0;
getTreeSum(root);
return this->res;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
int res = 0;
public int getTreeSum(TreeNode root){
if(root==null) return 0;
int leftSum = getTreeSum(root.left);
int rightSum = getTreeSum(root.right);
this.res += Math.abs(leftSum-rightSum);
return leftSum+rightSum+root.val;
}
public int findTilt(TreeNode root) {
this.res = 0;
getTreeSum(root);
return this.res;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.res = 0
def getTreeSum(self,root:TreeNode) -> int:
if root is None:
return 0
left = self.getTreeSum(root.left)
right = self.getTreeSum(root.right)
self.res += abs(left-right)
return left+right+root.val
def findTilt(self, root: TreeNode) -> int:
self.res = 0
self.getTreeSum(root)
return self.res
计算给定二叉树的所有左叶子之和。
示例:
3 / \ 9 20 / \ 15 7
在这个二叉树中,有两个左叶子,分别是 9 和 15,所以返回 24
来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/sum-of-left-leaves
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:递归遍历即可,关键是判断是否为左叶子。
左叶子:没有孩子的结点,并且是父节点的左孩子。
题解代码(C++):
/**
* 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:
int res = 0;
void dfs(TreeNode* root){
if(root==NULL) return;
if(root->left!=NULL && root->left->left==NULL && root->left->right==NULL)
this->res+=root->left->val;
dfs(root->left);
dfs(root->right);
}
int sumOfLeftLeaves(TreeNode* root) {
this->res = 0;
dfs(root);
return this->res;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
int res = 0;
public void dfs(TreeNode root){
if(root==null) return;
if(root.left!=null && root.left.left==null && root.left.right==null)
this.res+=root.left.val;
dfs(root.left);
dfs(root.right);
}
public int sumOfLeftLeaves(TreeNode root) {
this.res = 0;
dfs(root);
return this.res;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.res = 0
def dfs(self,root:TreeNode):
if root is None:
return None
if root.left is not None and root.left.left is None and root.left.right is None:
self.res += root.left.val
self.dfs(root.left)
self.dfs(root.right)
def sumOfLeftLeaves(self, root: TreeNode) -> int:
self.res = 0
self.dfs(root)
return self.res
你需要采用前序遍历的方式,将一个二叉树转换成一个由括号和整数组成的字符串。
空节点则用一对空括号 “()” 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。
示例 1:
输入: 二叉树: [1,2,3,4]
1 / \ 2 3 / 4
输出: “1(2(4))(3)”
解释: 原本将是“1(2(4)())(3())”, 在你省略所有不必要的空括号对之后, 它将是“1(2(4))(3)”。 示例 2:
输入: 二叉树: [1,2,3,null,4]
1 / \ 2 3 \ 4
输出: “1(2()(4))(3)”
解释: 和第一个示例相似, 除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/construct-string-from-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:
题目中已经提示了使用前序遍历,现在关键是加括号的规则:
1、如果当前结点没有孩子,不用加括号。
2、如果当前结点有两个孩子,加两个括号;
3、如果当前结点只有左孩子,只需加一个括号;
4、如果当前结点只有右孩子,不能省略左孩子的括号,还要加一个括号;
题解代码(C++):
/**
* 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:
string tree2str(TreeNode* t) {
if(t==NULL) return "";
if(t->left==NULL&&t->right==NULL) return to_string(t->val);
if(t->left!=NULL && t->right!=NULL) return to_string(t->val)+"("+tree2str(t->left)+")("+tree2str(t->right)+")";
if(t->left==NULL && t->right!=NULL) return to_string(t->val)+"()("+tree2str(t->right)+")";
else
return to_string(t->val)+"("+tree2str(t->left)+")";
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public String tree2str(TreeNode t) {
if(t==null) return "";
if(t.left==null&&t.right==null) return String.valueOf(t.val);
if(t.left!=null&&t.right!=null) return t.val+"("+tree2str(t.left)+")"+"("+tree2str(t.right)+")";
if(t.left==null&&t.right!=null) return t.val+"()"+"("+tree2str(t.right)+")";
else return t.val+"("+tree2str(t.left)+")";
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def tree2str(self, t: TreeNode) -> str:
if t is None:
return ""
if t.left is None and t.right is None:
return str(t.val)
if t.left is not None and t.right is not None:
return str(t.val)+"("+self.tree2str(t.left)+")"+"("+self.tree2str(t.right)+")"
if t.left is None and t.right is not None:
return str(t.val)+"()"+"("+self.tree2str(t.right)+")"
else:
return str(t.val)+"("+self.tree2str(t.left)+")"
给定一个二叉搜索树的根结点 root,返回树中任意两节点的差的最小值。
示例:
输入: root = [4,2,6,1,3,null,null] 输出: 1 解释: 注意,root是树结点对象(TreeNode
object),而不是数组。给定的树 [4,2,6,1,3,null,null] 可表示为下图:
4 / \ 2 6 / \ 1 3
最小的差值是 1, 它是节点1和节点2的差值, 也是节点3和节点2的差值。
注意:
二叉树的大小范围在 2 到 100。 二叉树总是有效的,每个节点的值都是整数,且不重复。
本题与530:https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:
二叉搜索树,按中序遍历,得到升序的输出结果,要求树中任意两节点的差的最小值,只可能出现在升序的数组两个相邻元素之差之中。
和【3.1、530. 二叉搜索树的最小绝对差】相似。
题解代码(C++):
/**
* 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:
int res = INT_MAX;
void dfs(TreeNode* root,TreeNode* &pre){
if(root==NULL) return;
dfs(root->left,pre);
if(pre==NULL) pre = root;
else{
if(res>root->val-pre->val)
this->res = root->val-pre->val;
pre = root;
}
dfs(root->right,pre);
}
int minDiffInBST(TreeNode* root) {
this->res = INT_MAX;
TreeNode* pre =NULL;
dfs(root,pre);
return this->res;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
int res = Integer.MAX_VALUE;
TreeNode pre = null;
public void dfs(TreeNode root){
if(root==null) return;
dfs(root.left);
if(this.pre == null) this.pre = root;
else{
if(this.res>root.val-this.pre.val)
this.res = root.val-this.pre.val;
this.pre = root;
}
dfs(root.right);
}
public int minDiffInBST(TreeNode root) {
this.res = Integer.MAX_VALUE;
this.pre = null;
dfs(root);
return this.res;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.res = pow(2,32)-1
self.pre = None
def dfs(self,root:TreeNode):
if root is None:
return None
self.dfs(root.left)
if self.pre is None:
self.pre = root
else:
if self.res > root.val-self.pre.val:
self.res = root.val-self.pre.val
self.pre = root
self.dfs(root.right)
def minDiffInBST(self, root: TreeNode) -> int:
self.res = pow(2,32)-1
self.pre = None
self.dfs(root)
return self.res
给定一个二叉树,判断它是否是高度平衡的二叉树。
本题中,一棵高度平衡二叉树定义为:
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]
3 / \ 9 20 / \ 15 7
返回 true 。
示例 2:给定二叉树 [1,2,2,3,3,null,null,4,4]
1 / \ 2 2 / \ 3 3 / \ 4 4
返回 false 。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/balanced-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:
根据平衡二叉树的定义,左右子树高度差绝对值不超过1,可以使用求树的高度的函数来求左右子树的高度,然后判断是否平衡。
有两种求法:
1、自顶向下:
bool isBalanced(TreeNode* root){
if(root==NUll) return true;
int leftHight = getHight(root->left);
int rightHight = getHight(root->left);
return abs(leftHight-rightHight)<=1 && isBalanced(root->left) && isBalanced(root->right);
}
缺点:求高度的时候冗余量特别大,有很多重复计算,强烈不推荐!
2、自底向上:
优点:减少重复计算。
缺点:需要好好的理解一番。
判断平衡二叉树本质上是判断子树高度,在求树的高度的时候,使用了递归,可以在递归的过程中判断是否平衡,而求高度就是自底向上的计算方法。
下面是自底向上的方法:
题解代码(C++):
/**
* 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:
int isBalancedHelper(TreeNode* root){
if(root==NULL) return 0;
int leftH = isBalancedHelper(root->left);
int rightH = isBalancedHelper(root->right);
if(leftH==-1 || rightH==-1) return -1;//发现不平衡就返回-1
if(abs(leftH-rightH)>1) return -1;//不平衡就返回-1
else return max(leftH,rightH)+1; //平衡就返回高度
}
bool isBalanced(TreeNode* root) {
if(isBalancedHelper(root)==-1) return false;
else return true;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int isBalancedHelper(TreeNode root){
if(root==null) return 0;
int l = isBalancedHelper(root.left);
int r = isBalancedHelper(root.right);
if(l==-1 || r ==-1) return -1;
if(Math.abs(l-r)>1) return -1;
else return Math.max(l,r)+1;
}
public boolean isBalanced(TreeNode root) {
if(isBalancedHelper(root)==-1) return false;
else return true;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isBalancedHelper(self,root:TreeNode) -> int:
if root is None:
return 0
l = self.isBalancedHelper(root.left)
r = self.isBalancedHelper(root.right)
if l==-1 or r==-1:
return -1
if abs(l-r)>1:
return -1
else:
return max(l,r)+1
def isBalanced(self, root: TreeNode) -> bool:
if self.isBalancedHelper(root) == -1:
return False
else:
return True
在二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。
如果二叉树的两个节点深度相同,但父节点不同,则它们是一对堂兄弟节点。
我们给出了具有唯一值的二叉树的根节点 root,以及树中两个不同节点的值 x 和 y。
只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true。否则,返回 false。
输入:root = [1,2,3,4], x = 4, y = 3
输出:false
示例 2:
输入:root = [1,2,3,null,4,null,5], x = 5, y = 4
输出:true
示例 3:
输入:root = [1,2,3,null,4], x = 2, y = 3 输出:false
提示:
二叉树的节点数介于 2 到 100 之间。 每个节点的值都是唯一的、范围为 1 到 100 的整数。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/cousins-in-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:
遍历,比较值,找到x,y就记录父节点和深度,最后比较。
题解代码(C++):
/**
* 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:
void dfs(TreeNode* root,int d,TreeNode* pre, int &x, int &y,int &dx,int &dy,TreeNode*& px,TreeNode*& py){
if(root ==NULL) return;
if(pre ==NULL) pre = root;
else{
if(root->val==x){
dx = d;
px = pre;
}else if(root->val==y){
dy = d;
py = pre;
}
pre = root;
}
dfs(root->left,d+1,pre,x,y,dx,dy,px,py);
dfs(root->right,d+1,pre,x,y,dx,dy,px,py);
}
bool isCousins(TreeNode* root, int x, int y) {
int dx,dy;
TreeNode *px,*py = NULL;
dfs(root,0,NULL,x,y,dx,dy,px,py);
if(px!=py&&dx==dy) return true;
else return false;
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
TreeNode px,py;
int dx,dy;
public void dfs(TreeNode root,int d,TreeNode pre,int x,int y){
if(root==null) return;
if(pre ==null) pre = root;
else{
if(root.val==x){
this.px = pre;
this.dx = d;
}else if(root.val==y){
this.py = pre;
this.dy = d;
}
pre = root;
}
dfs(root.left,d+1,pre,x,y);
dfs(root.right,d+1,pre,x,y);
}
public boolean isCousins(TreeNode root, int x, int y) {
this.px=this.py=null;
this.dx=this.dy=0;
dfs(root,0,null,x,y);
if(this.px!=this.py&&this.dx==this.dy) return true;
else return false;
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.px,self.py = None,None
self.dx,self.dy = 0,0
def dfs(self,root:TreeNode,d:int,pre:TreeNode,x:int,y:int):
if root is None:
return None
if pre is None:
pre = root
else:
if root.val == x:
self.px = pre
self.dx = d
elif root.val==y:
self.py = pre
self.dy = d
pre = root
self.dfs(root.left,d+1,pre,x,y)
self.dfs(root.right,d+1,pre,x,y)
def isCousins(self, root: TreeNode, x: int, y: int) -> bool:
self.px,self.py = None,None
self.dx,self.dy = 0,0
self.dfs(root,0,None,x,y)
if self.px is not self.py and self.dx == self.dy:
return True
else:
return False
给定一个二叉树,检查它是否是镜像对称的。
例如,二叉树 [1,2,2,3,4,4,3] 是对称的。
1 / \ 2 2 / \ / \ 3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1 / \ 2 2 \ \ 3 3
来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/symmetric-tree
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
思路解析:判断对称的二叉树,本质是判断树是否相等,只不过是左右孩子的位置互换了一下。
题解代码(C++):
/**
* 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:
bool isSame(TreeNode* root1,TreeNode* root2){
if((root1==NULL && root2!=NULL) || (root1!=NULL && root2==NULL)) return false;
if(root1==NULL && root2==NULL) return true;
return root1->val==root2->val && isSame(root1->left,root2->right) && isSame(root1->right,root2->left);
}
bool isSymmetric(TreeNode* root) {
if(root==NULL) return true;
return isSame(root->left,root->right);
}
};
题解代码(Java):
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public boolean isSame(TreeNode r1,TreeNode r2){
if(r1==null && r2==null) return true;
if(r1!=null && r2 == null) return false;
if(r1==null && r2 !=null) return false;
return r1.val==r2.val && isSame(r1.left,r2.right) && isSame(r1.right,r2.left);
}
public boolean isSymmetric(TreeNode root) {
if(root==null) return true;
return isSame(root.left,root.right);
}
}
题解代码(Python):
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSame(self,r1:TreeNode,r2:TreeNode) -> bool:
if r1 is None and r2 is None:
return True
if r1 is not None and r2 is None:
return False
if r1 is None and r2 is not None:
return False
return r1.val==r2.val and self.isSame(r1.left,r2.right) and self.isSame(r1.right,r2.left)
def isSymmetric(self, root: TreeNode) -> bool:
if root is None:
return True
return self.isSame(root.left,root.right)