Leetcode刷题——树篇3

最新推荐文章于 2020-07-08 17:01:22 发布
最新推荐文章于 2020-07-08 17:01:22 发布
阅读量337 收藏
点赞数
分类专栏： 刷题打基础系列 文章标签： 二叉树 算法 数据结构 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w137093940/article/details/105610648
版权

文章目录

3、树（简单篇3）

3.1、530. 二叉搜索树的最小绝对差

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。
示例：
输入：
在这里插入图片描述
输出： 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

3.2、653. 两数之和 IV - 输入 BST

给定一个二叉搜索树和一个目标结果，如果 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

3.3、437. 路径总和 III

给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。
示例：
root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

      10
     /  \
    5   -3    
   / \    \   
  3   2   11  
 / \   \ 
3  -2   1

返回 3。和等于 8 的路径有:

  1. 5 -> 3
  2. 5 -> 2 -> 1
  3. -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

3.4、563. 二叉树的坡度

给定一个二叉树，计算整个树的坡度。
一个树的节点的坡度定义即为，该节点左子树的结点之和和右子树结点之和的差的绝对值。空结点的的坡度是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.5、404. 左叶子之和

计算给定二叉树的所有左叶子之和。

示例：

    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

3.6、606. 根据二叉树创建字符串

你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。

空节点则用一对空括号 “()” 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。

示例 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)+")"

3.7、783. 二叉搜索树结点最小距离

给定一个二叉搜索树的根结点 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

3.8、110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过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

3.9、993. 二叉树的堂兄弟节点

在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。

如果二叉树的两个节点深度相同，但父节点不同，则它们是一对堂兄弟节点。

我们给出了具有唯一值的二叉树的根节点 root，以及树中两个不同节点的值 x 和 y。

只有与值 x 和 y 对应的节点是堂兄弟节点时，才返回 true。否则，返回 false。

示例 1：
在这里插入图片描述

输入：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

3.10、101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [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)
星辰戟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【每日一题(3)】快乐的跳跃者 UESTC - 508
Winsoul Blog
12-03 2051
快乐的跳跃者 UESTC - 508 对于一个包含n(n>0)个元素的整数序列，如果序列中相邻元素之差的绝对值取遍从1到n−1的所有整数，那么这个序列就叫做jolly jumper。例如：1 4 2 3 就是一个jolly jumper，因为相邻元素之差的绝对值分别为3、2、1。写一个程序来判断一个序列是不是jolly jumper。 Input 有T组测试数据。输入的第一行是数据组数T，其
LeetCode刷题——Complex multiplication复数乘法
12-21
在LeetCode刷题的过程中，我们经常会遇到各种类型的挑战，其中包括涉及数学和字符串处理的问题。"Complex multiplication"（复数乘法）就是一个典型的例子，它将基础的数学概念与编程技巧结合在一起，要求我们理解...
【leetcode 简单】 第九十四题 左叶子之和
weixin_30569001的博客
08-27 131
计算给定二叉树的所有左叶子之和。 示例： 3 / \ 9 20 / \ 15 7 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24 # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x):...
Leetcode_437 路径总和 III
Ding_xiaofei的博客
08-10 359
题目描述 root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8 10 / \ 5 -3 / \ \ 3 2 11 / \ \ 3 -2 1 Return 3. The paths that sum to 8 are: 1. 5 -&amp;gt; 3 2. 5 -&amp;gt; ...
【LeetCode 简单题】97-路径总和III
weixin_41011942的博客
11-15 333
声明： 今天是第97道题。给定一个二叉树，它的每个结点都存放着一个整数值，找出路径和等于给定数值的路径总数。以下所有代码经过楼主验证都能在LeetCode上执行成功，代码也是借鉴别人的，在文末会附上参考的博客链接，如果侵犯了博主的相关权益，请联系我删除 （手动比心ღ( ´･ᴗ･` )） 正文 题目：给定一个二叉树，它的每个结点都存放着一个整数值。找出路径和等于给定数值的路径总数。路径不需要...
【LeetCode】一棵树引发的算法题...
qq_36452584的博客
07-08 244
今天是 Kevin 的算法之路的第5天。为大家讲解 LeetCode 第 108 题，是一道简单难度的题目。 同时今天也是今年高考的第一天，Kevin 在这预祝考生们考试顺利，7开得胜！ 每日一笑 睡觉的时候突然惊醒过来，想起自己的作业还没有写，赶紧匆忙的爬起来找纸笔，找了好一会都没找着，就想起来了，自己已经毕业很久了，哪里还要写作业啊。安心的去睡觉了，早上起来看到桌上的书包，才发现昨天自己是做梦呢。 题目描述 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。 本题中，一个高度平衡二叉树
LeetCode刷题——91. 解码方法
12-20
【LeetCode刷题——91. 解码方法】 这道编程题目来自LeetCode，主要考察的是动态规划和递归解题技巧。问题的核心是给定一个仅由数字组成的非空字符串，我们需要计算出该字符串有多少种不同的解码方法，这里的解码是...
LeetCode刷题——62. 不同路径
12-20
【LeetCode刷题——62. 不同路径】这道题目是经典的动态规划问题，主要考察的是算法设计和实现能力。题目描述了一个机器人在m x n的网格中，从左上角开始，每次只能向下或向右移动一步，目标是到达右下角。求解从...
LeetCode刷题——旋转图片
12-23
旋转图片题目的思路探讨与源码 旋转图片的题目如下图，核心是把一个矩阵进行顺时针90度的旋转，并且只能在当前矩阵上改动，不能新建矩阵，所以只需要把该矩阵旋转...matrix=[[1,2,3],[4,5,6],[7,8,9]] print(matrix)
LeetCode- 面试题32 - I. 从上到下打印二叉树
保持对编程的热情！
02-22 203
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。 例如: 给定二叉树:[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回： [3,9,20,15,7] 提示： 节点总数 <= 1000 通过次数1,281提交次数1,930 这题做过，没什么说的。 #inc...
404. 左叶子之和
qq_31699373的博客
09-07 121
我是采用一个，参数中加入一个flag的技巧，自己AC的。如果是左孩子，则遍历时，flag置为1;否则如果是右孩子，flag置为2. class Solution { public:     int ret;     void dfs(TreeNode* root,int flag)     {         if(root==NULL) return;         dfs(root-&gt...
面试中常见二叉树的各种操作
橘嘉禾
03-12 749
本篇针对面试中常见的二叉树操作作个总结： 前序遍历，中序遍历，后序遍历； 1.1 前序遍历 对于当前结点，先输出该结点，然后输出它的左孩子，最后输出它的右孩子。以上图为例，递归的过程如下： 输出 1，接着左孩子； 输出 2，接着左孩子； 输出 4，左孩子为空，再接着右孩子； 输出 6，左孩子为空，再接着右孩子； 输出 7，左右孩子都为空，此时 2 的左子树全部输出，2 的右子树为空，...
leetcode刷题（六）路径总和I、II、III
weixin_38368941的博客
05-13 6209
（一）112题题目地址：https://leetcode-cn.com/problems/path-sum/description/题目描述：给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。解决方案：/** * Definition for a binary tree node. * struct TreeNode { *     int ...
Leetcode 437：路径总和 III（最详细的解法！！！）
coordinate的博客
09-01 5860
给定一个二叉树，它的每个结点都存放着一个整数值。 找出路径和等于给定数值的路径总数。 路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。 二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。 示例： root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8...
leetcode 563. 二叉树的坡度(python)
汤庆
07-15 1020
给定一个二叉树，计算整个树的坡度。 一个树的节点的坡度定义即为，该节点左子树的结点之和和右子树结点之和的差的绝对值。空结点的的坡度是0。 整个树的坡度就是其所有节点的坡度之和。 示例: 输入: 1 / \ 2 3 输出: 1 解释: 结点的坡度 2 : 0 结点的坡度 3 : 0 结点的坡度 1 : |2-3| = 1 树的坡度...
Code the Tree（图论，树）
weixin_30808575的博客
07-31 160
ZOJ Problem Set - 1097 Code the TreeTime Limit:2 Seconds Memory Limit:65536 KB A tree (i.e. a connected graph without cycles) with vertices numbered by the integers1, 2, ..., nis given. The...
二叉树的路径处理问题
E_N_T_J的博客
12-10 336
路径处理问题，实质上是使用树的遍历方法对树进行遍历，常常采用树的先序遍历方法对树进行遍历，对树的先序遍历方法稍加改动，改动先序遍历时对中间节点的处理逻辑和对左右子树的处理逻辑来实现题目的要求。 处理从根节点到每一个叶子节点的路径（即该二叉树的所有路径）上的所有节点，          例如leetcode257，问题描述及代码如下：          问题描述：          给定一个二...
算法与数据结构学习之路三：算法与数据结构的融合应用 -- 树
柠檬草的味道
12-19 255
文章目录二、树1. 普通二叉树2. 二叉搜索树(BST) 二、树    面对树的数据结构问题，重点是要理解不同种类的树的性质，以及其运算过程。在树的数据结构中，常用递归来求解，必须熟悉掌握递归过程中的逻辑关系。    针对树数据结构的递归问题，通常通过以下一个三个步骤去理解和建立递归：    ① 整个递归的终止条件及终止后的返回值。    ② 找到递归的返回值-注意，这里的递归返回值与终止后...
437. 路径总和 III
quekai01的博客
09-12 102
437. 路径总和 III 给定一个二叉树，它的每个结点都存放着一个整数值。 找出路径和等于给定数值的路径总数。 路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。 二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。 示例： root = [10,5,-3,3,2,null,11,3,-2,...
LeetCode刷题攻略：二分法与双指针模板
这篇文档主要涵盖了LeetCode刷题中常见的两种算法模板——二分法和双指针法，并提供了相应的代码模板、关键属性和具体题目的应用示例。以下是对这两种方法的详细解释： 1. 二分法 - 什么是二分查找：二分查找是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值