之前断了一段时间没做Leetcode，深感愧疚，重新续上

题目1 ID104

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

3

/ \

9  20

/  \

15   7

返回它的最大深度 3 。

我的解答：

使用递归求二叉树的最大深度，想要求根节点的最大深度，需要求其左右两个节点中更大的深度+1,想要求左右两个节点的深度也是如此，代码如下:

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9.  
  10. int maxDepth(struct TreeNode* root){
  11.     int leftDepth,rightDepth;
  12.     if(root==NULL){
  13.         return 0;
  14.     }else{
  15.         leftDepth=maxDepth(root->left);
  16.         rightDepth=maxDepth(root->right);
  17.         return leftDepth>rightDepth?leftDepth+1:rightDepth+1;
  18.     }
  19. }

　　

题目2 ID102

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：

二叉树：[3,9,20,null,null,15,7],

3

/ \

9  20

/  \

15   7

返回其层次遍历结果：

[

[3],

[9,20],

[15,7]

]

我的解答：

在这里没有采用逐层遍历，而是使用的dfs深度优先遍历的方式，将每一个节点的值放入相对应的列表里，使用level判断层数，levels储存得到的所有节点值，树的最高层次即len(levels)，添加新列表储存节点值的判断是由当前树的最高层次和当前节点所在层数比较得到的，如果当前节点所在层数大于树的最高层次，证明需要添加一个新列表储存值。get函数递归非空的孩子节点，参数是node当前节点和level当前节点层数：

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def levelOrder(self, root: TreeNode) -> List[List[int]]:
  10.         levels=[]
  11.         if not root:
  12.             return levels
  13.         def get(node,level):
  14.             if len(levels)==level:
  15.                 levels.append([])
  16.             levels[level].append(node.val)
  17.             if node.left:
  18.                 get(node.left,level+1)
  19.             if node.right:
  20.                 get(node.right,level+1)
  21.         get(root,0)
  22.         return levels

　　

题目3 ID100

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1

/ \       / \

2   3     2   3

[1,2,3],   [1,2,3]

输出: true

示例 2:

输入:      1          1

/           \

2             2

[1,2],     [1,null,2]

输出: false

示例 3:

输入:       1         1

/ \       / \

2   1     1   2

[1,2,1],   [1,1,2]

输出: false

我的解答：

可以想到采用递归判断的方式，如果两个节点都是空的话，就返回true，其中一个是空的话，就返回false，然后再判断两个非空节点的val值是否相同，不同的话返回flase，递归判断两棵树的孩子节点

Python3代码：

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
  10.         if not p and not q:
  11.             return True
  12.         if not p or not q:
  13.             return False
  14.         if p.val!=q.val:
  15.             return False
  16.         return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)

　　

C语言代码：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9.  
  10. bool isSameTree(struct TreeNode* p, struct TreeNode* q){
  11.     if(p==NULL&&q==NULL){
  12.         return true;
  13.     }
  14.     if(p==NULL||q==NULL){
  15.         return false;
  16.     }
  17.     if(p->val!=q->val){
  18.         return false;
  19.     }
  20.     return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
  21. }

　　

题目4 ID101

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

例如，二叉树 [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

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

我的解答：

评论区里面的老哥说的很好，其实主要是理解递归的思想：

我们首先判断根节点是否为空，非空的时候再判断其左右子树是否对称，左树的左孩子需要和右树的右孩子对称，左树的右孩子需要和右树的左孩子对称，先比较当前节点的值是否相同，再递归判断其左右孩子的对称情况，写写就知道了：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9.  
  10. bool check(struct TreeNode* node1,struct TreeNode* node2){
  11.     if(node1==NULL&&node2==NULL){
  12.         return true;
  13.     }
  14.     if(node1==NULL||node2==NULL){
  15.         return false;
  16.     }
  17.     if(node1->val!=node2->val){
  18.         return false;
  19.     }
  20.     return node1->val==node2->val&&check(node1->left,node2->right)&&check(node1->right,node2->left);
  21. }
  22. bool isSymmetric(struct TreeNode* root){
  23.     if(root==NULL){
  24.         return true;
  25.     }
  26.     return check(root->left,root->right);
  27. }

　　

题目5 ID107

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：

给定二叉树 [3,9,20,null,null,15,7],

3

/ \

9  20

/  \

15   7

返回其自底向上的层次遍历为：

[

[15,7],

[9,20],

[3]

]

我的解答：

与ID100题相同，最后只需要将列表反转，这里使用python的切片操作，levels[::-1]，表示从,后往前取，每次步进值为1，达到了反转列表的效果。

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
  10.         levels=[]
  11.         if not root:
  12.             return levels
  13.         def get_node(node,level):
  14.             if len(levels)==level:
  15.                 levels.append([])
  16.             levels[level].append(node.val)
  17.             if node.left:
  18.                 get_node(node.left,level+1)
  19.             if node.right:
  20.                 get_node(node.right,level+1)
  21.         get_node(root,0)
  22.         return levels[::-1]

　　

题目6 ID111

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

3

/ \

9  20

/  \

15   7

返回它的最小深度  2.

我的解答：

最开始的代码是这样的：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9. int min_num(int a,int b){
  10.     return a<b?a:b;
  11. }
  12. int min(struct TreeNode* node,int level){
  13.     if(node==NULL){
  14.         return 9999;
  15.     }
  16.     if(node->left==NULL&&node->right==NULL){
  17.         return level+1;
  18.     }else{
  19.         return min_num(min(node->left,level+1),min(node->right,level+1));
  20.     }
  21. }
  22. int minDepth(struct TreeNode* root){
  23.     if(root==NULL){
  24.         return 0;
  25.     }
  26.     return min(root,0);
  27. }

　　

如果根节点为空，那么我们就返回0，否则进入自己构造的min函数，因为题目给出的函数minDepth函数没有给出树的层次，为了方便重新创建了min函数，传入参数为当前节点和当前节点所在层数，如果这个节点是NULL的话，返回9999，也就是当前节点为空节点，加上很大的数，使其不能够成为最短的。这是为了避免出现[1,2]这种情况，叶子节点并不是根节点，所以[1,2]对应的答案是2，而不是1。接着判断当前节点是否是叶子节点，是的话返回层数+1，不是的话继续递归当前节点的叶子节点，取其中较小值。

但是如return 9999，以及重新定义min函数，这些地方处理不是很好。测试案例过大的话还是会出错，重新整理思路为：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9. int min_num(int a,int b){
  10.     return a<b?a:b;
  11. }
  12. int minDepth(struct TreeNode* root){
  13.     if(root==NULL){
  14.         return 0;
  15.     }
  16.     if(root->left==NULL&&root->right==NULL){
  17.         return 1;
  18.     }
  19.     int minleft=minDepth(root->left);
  20.     int minright=minDepth(root->right);
  21.     if(root->left==NULL||root->right==NULL){
  22.         return minleft+minright+1;
  23.     }
  24.     return min_num(minleft,minright)+1;
  25. }

　　

在寻找树的根到叶子结点一共有四种情况，1，当前节点为null，返回0；2，当前节点的左孩子和右孩子都为null，这符合了叶子节点的定义，返回1,；3，当前节点的左孩子和右孩子中有一个是NULL，空节点的值为0，对结果不造成影响，不需要判断是左孩子和右孩子中的哪一个，直接返回 左孩子的深度+右孩子的深度+1即可；4，两个节点都不为空，正常处理，返回其较小的那一个深度+1。

题目7 ID面试题04.02

给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一棵高度最小的二叉搜索树。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

0

/ \

-3   9

/   /

-10  5

我的解答：

树的操作平时遇到很少，要加大训练

给我们的是一个升序的整数数组，在二叉树的遍历中，中序遍历得到的也是一个升序数组，证明这道题是想让我们进行逆操作，把整数数组还原回去，但是又需要是高度最小，高度最小即只在树的最底层存在叶子结点。而为了达到高度最小，我们每次从数组的中间进行递归，二叉搜索树，按照值来判断的话，有：左子树<根<右子树，我们每次从数组的中间进行划分，刚好符合这个条件，另外递归结束的条件是数组里面没有能够划分的值的时候，返回NULL，边界处的判断需要注意，代码如下：

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
  10.             left,right=0,len(nums)-1
  11.             if left>right:
  12.                 return None
  13.             mid=len(nums)//2
  14.             root=TreeNode(nums[mid])
  15.             root.left=self.sortedArrayToBST(nums[:mid])
  16.             root.right=self.sortedArrayToBST(nums[mid+1:])
  17.             return root

　　

题目8 ID559

实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两棵子树的高度差不超过 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 。

我的解答：

想要知道一棵树是否是平衡的，它的两棵子树高度差需要不超过1，使用GetLength函数求树的深度，check函数判断两个树结点的高度之差是否超过1，超过1返回false，不超过返回true。从根节点开始向下递归，如果当前结点是空节点，则返回true，空树一定是平衡的，否则使用check函数判断其左右子树高度差，若暂时为平衡的，则递归判断左子树和右子树是否是平衡的，若不平衡，则直接返回false，代码如下：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9.  
  10. //求树的深度
  11. int GetLength(struct TreeNode* root){
  12.     if(root==NULL){
  13.         return 0;
  14.     }
  15.     int leftlength=GetLength(root->right);
  16.     int rightlength=GetLength(root->left);
  17.     return (leftlength>rightlength?leftlength:rightlength)+1;
  18. }
  19. bool check(struct TreeNode* left,struct TreeNode* right){
  20.     if(GetLength(left)-GetLength(right)>1||GetLength(left)-GetLength(right)<-1){
  21.         return false;
  22.     }else{
  23.         return true;
  24.     }
  25. }
  26. bool isBalanced(struct TreeNode* root){
  27.     if(root==NULL){
  28.         return true;
  29.     }
  30.     if(check(root->left,root->right)){
  31.         return isBalanced(root->left)&&isBalanced(root->right);
  32.     }else{
  33.         return false;
  34.     }
  35.  
  36. }

　　

题目9 ID530

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

输入：

1

\

3

/

2

输出：

1

解释：

最小绝对差为 1，其中 2 和 1 的差的绝对值为 1（或者 2 和 3）。

提示：

树中至少有 2 个节点。

本题与 783 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ 相同

我的解答：

二叉搜索树的特点是，在任意一个当前结点，如果其左右子树不为空，则左子树的根节点值一定小于当前结点，右子树的根节点值一定大于当前结点，所以我们中序遍历二叉搜索树得到的列表值一定是一个递增数列，得到中序遍历的列表后，计算列表中相邻值的差是否与当前的最小值小，若比当前最小值小，则替换最小值，否则保持不变，继续遍历列表。

代码如下：

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def SortIn(self,root:TreeNode):
  10.         if root==None:
  11.             return None
  12.         self.SortIn(root.left)
  13.         self.treelist.append(root.val)
  14.         self.SortIn(root.right)
  15.  
  16.     def getMinimumDifference(self, root: TreeNode) -> int:
  17.         self.treelist=[]
  18.         self.SortIn(root)
  19.         minnum=self.treelist[1]-self.treelist[0]
  20.         for i in range(len(self.treelist)-1):
  21.             if self.treelist[i+1]-self.treelist[i]<minnum:
  22.                 minnum=self.treelist[i+1]-self.treelist[i]
  23.         return minnum

　　

题目10 ID559

给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

例如：

输入: 原始二叉搜索树:

5

/   \

2     13

输出: 转换为累加树:

18

/   \

20     13

我的解答：

从二叉搜索树的特性出发，二叉搜索树的中序遍历结果是一个升序序列，使用SortIn函数中序遍历得到该序列后，我们使用SortInTwo函数重新遍历二叉搜索树，对于每一个结点，我们都遍历升序序列，将大于结点的值加在当前结点val上，使用AddVal函数实现，二叉树遍历结束后，得到的新树就是累加树了。

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def SortIn(self,root:TreeNode):
  10.         if root==None:
  11.             return None
  12.         self.SortIn(root.left)
  13.         self.sortlist.append(root.val)
  14.         self.SortIn(root.right)
  15.     def AddVal(self,root):
  16.         temp=0
  17.         for i in self.sortlist:
  18.             if i>root.val:
  19.                 temp+=i
  20.         root.val+=temp
  21.     def SortInTwo(self,root:TreeNode):
  22.         if root==None:
  23.             return None
  24.         self.SortInTwo(root.left)
  25.         self.AddVal(root)
  26.         self.SortInTwo(root.right)
  27.  
  28.     def convertBST(self, root: TreeNode) -> TreeNode:
  29.         self.sortlist=[]
  30.         self.SortIn(root)
  31.         self.SortInTwo(root)
  32.         return root

　　

题目11 ID543

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

示例 :

给定二叉树

1

/ \

2   3

/ \

4   5

返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。

注意：两结点之间的路径长度是以它们之间边的数目表示。

我的解答：

分析题目可以知道求直径实际上是求树结点最大的左子树深度和右子树深度之和，使用maxlength全局变量存储当前最大直径，遍历二叉树，对每一个结点求其左子树和右子树的深度之和，再与maxlength进行比较，大于maxlength则替换，否则maxlength不变，最后返回maxlength。

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9. int maxlength=0;
  10. int GetTreeLength(struct TreeNode* root){
  11.     if(root==NULL){
  12.         return 0;
  13.     }
  14.     int left=GetTreeLength(root->left);
  15.     int right=GetTreeLength(root->right);
  16.     if(left+right>maxlength){
  17.         maxlength=left+right;
  18.     }
  19.     return (left>right?left:right)+1;
  20. }
  21. int diameterOfBinaryTree(struct TreeNode* root){
  22.     maxlength=0;
  23.     GetTreeLength(root);
  24.     return maxlength;
  25. }

　　

题目12 ID563

给定一个二叉树，计算整个树的坡度。

一个树的节点的坡度定义即为，该节点左子树的结点之和和右子树结点之和的差的绝对值。空结点的的坡度是0。

整个树的坡度就是其所有节点的坡度之和。

示例:

输入:

1

/   \

2     3

输出: 1

解释:

结点的坡度 2 : 0

结点的坡度 3 : 0

结点的坡度 1 : |2-3| = 1

树的坡度 : 0 + 0 + 1 = 1

注意:

任何子树的结点的和不会超过32位整数的范围。

坡度的值不会超过32位整数的范围。

我的解答：

按照树节点坡度的定义：该节点左子树的结点之和和右子树结点之和的差的绝对值，使用递归求子树节点之和。我们遍历整棵树，求每个结点的坡度之和即可，使用AbsVal函数求两个数的之差的绝对值。

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9. int AbsVal(int a,int b){
  10.     if(a>b){
  11.         return a-b;
  12.     }
  13.     return b-a;
  14. }
  15. int AddVal(struct TreeNode* root){
  16.     if(root==NULL){
  17.         return 0;
  18.     }
  19.     return root->val+AddVal(root->left)+AddVal(root->right);
  20. }
  21. int findTilt(struct TreeNode* root){
  22.     if(root==NULL){
  23.         return 0;
  24.     }
  25.     return AbsVal(AddVal(root->left),AddVal(root->right))+findTilt(root->left)+findTilt(root->right);
  26.  
  27. }

　　

题目13 ID572

给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。

示例 1:

给定的树 s:

3

/ \

4   5

/ \

1   2

给定的树 t：

4

/ \

1   2

返回 true，因为 t 与 s 的一个子树拥有相同的结构和节点值。

示例 2:

给定的树 s：

3

/ \

4   5

/ \

1   2

/

0

给定的树 t：

4

/ \

1   2

返回 false。

我的解答：

判断二叉树t是否是s的子树，要么t与s是相同的树，要么t是s左子树的子树，要么t是s右子树的子树，以此标准做判断递归。isEqual函数用来判断两棵树是否相同。

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9.  
  10. bool isEqual(struct TreeNode* s,struct TreeNode* t){
  11.     if(s==NULL&&t==NULL){
  12.         return true;
  13.     }
  14.     return s&&t&&(s->val==t->val)&&isEqual(s->left,t->left)&&isEqual(s->right,t->right);
  15. }
  16. bool isSubtree(struct TreeNode* s, struct TreeNode* t){
  17.     if(s==NULL&&t==NULL){
  18.         return true;
  19.     }
  20.     if(s==NULL&&t!=NULL){
  21.         return false;
  22.     }
  23.     return isEqual(s,t)||isSubtree(s->left,t)||isSubtree(s->right,t);
  24. }

　　

题目14 ID606

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

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

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

解释: 和第一个示例相似，

除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。

我的解答：

题目描述不太好，事实上，对于左子树为空的时候，需要留()括号，右子树为空的时候，可以直接忽略。我们按照题目要求进行递归。若根节点为空的时候，直接返回空字符串，如果根节点的左子树和右子树都为空的时候，直接返回根节点的val，特殊情况不满足的时候进入正常递归，左子树为空的时候，返回字符串添加()，不为空的话使用()括号包裹左子树的递归值，继续递归左子树，对于右子树，只有当其非空的时候使用括号包裹其递归值，最后返回context结果字符串。

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def tree2str(self, t: TreeNode) -> str:
  10.         if not t:
  11.             return ""
  12.         if not t.left and not t.right:
  13.             return str(t.val)
  14.         context=str(t.val)
  15.         if t.left:
  16.             context+="("+self.tree2str(t.left)+")"
  17.         else:
  18.             context+="()"
  19.         if t.right:
  20.             context+="("+self.tree2str(t.right)+")"
  21.         return context

　　

题目15 ID617

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

输入:

Tree 1                     Tree 2

1                         2

/ \                       / \

3   2                     1   3

/                           \   \

5                             4   7

输出:

合并后的树:

3

/ \

4   5

/ \   \

5   4   7

注意: 合并必须从两个树的根节点开始。

我的解答：

我们使用t1二叉树的根节点作为新树的根节点。树合并的时候的操作有：当两棵二叉树的树结点都为空的时候，返回None空节点，当两棵树结点中有一个为空的时候，返回另一颗非空树结点。当两棵树的结点都不为空的时候，将结点值val相加，并存储在t1的值中，同时继续递归两棵二叉树的左子树和右子树，将递归后的树结点赋给t1的左子树或右子树。

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, x):
  4. #         self.val = x
  5. #         self.left = None
  6. #         self.right = None
  7.  
  8. class Solution:
  9.     def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
  10.         if not t1 and not t2:
  11.             return None
  12.         if not t1:
  13.             return t2
  14.         if not t2:
  15.             return t1
  16.         if t1 and t2:
  17.             t1.val+=t2.val
  18.             t1.left=self.mergeTrees(t1.left,t2.left)
  19.             t1.right=self.mergeTrees(t1.right,t2.right)
  20.             return t1

　　

题目16 ID110

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

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

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

我的解答：

之前做过相同的题目，再次遇到重做一遍，代码如下：

  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     struct TreeNode *left;
  6.  *     struct TreeNode *right;
  7.  * };
  8.  */
  9.  
  10. int GetLength(struct TreeNode* root){
  11.     if(root==NULL){
  12.         return 0;
  13.     }
  14.     int leftlength=GetLength(root->left);
  15.     int rightlength=GetLength(root->right);
  16.     return (leftlength>rightlength?leftlength:rightlength)+1;
  17. }
  18. int absval(int a,int b){
  19.     if(a>b){
  20.         return a-b;
  21.     }
  22.     return b-a;
  23. }
  24. bool CheckTree(struct TreeNode* left,struct TreeNode* right){
  25.     if(absval(GetLength(left),GetLength(right))>1){
  26.         // printf("%d %d\n",GetLength(left),GetLength(right));
  27.         // printf("%d %d\n",left->val,right->val);
  28.         return false;
  29.     }
  30.     return true;
  31. }
  32. bool isBalanced(struct TreeNode* root){
  33.     if(root==NULL){
  34.         return true;
  35.     }
  36.     return CheckTree(root->left,root->right)&&isBalanced(root->left)&&isBalanced(root->right);
  37. }

　　

Leetcode学习笔记（5）的更多相关文章

  1. Leetcode学习笔记（4）

    题目1 ID121 给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格. 如果你最多只允许完成一笔交易(即买入和卖出一支股票),设计一个算法来计算你所能获取的最大利润. 注意你不能在买入股 ...

  2. Leetcode学习笔记（2）

    题目1 ID面试题 01.04 给定一个字符串,编写一个函数判定其是否为某个回文串的排列之一. 回文串是指正反两个方向都一样的单词或短语.排列是指字母的重新排列. 回文串不一定是字典当中的单词. 示例 ...

  3. Leetcode学习笔记（1）

    scrapy爬虫的学习告一段落,又因为现在在学习数据结构,做题平台是lettcode:https://leetcode-cn.com/ 每周都要交一次做题的笔记,所以把相关代码和思路同时放在博客上记录 ...

  4. leetcode学习笔记--开篇

    1 LeetCode是什么? LeetCode是一个在线的编程测试平台,国内也有类似的Online Judge平台.程序开发人员可以通过在线刷题,提高对于算法和数据结构的理解能力,夯实自己的编程基础. ...

  5. Leetcode学习笔记（3）

    题目1 ID88 给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 num1 成为一个有序数组. 说明: 初始化 nums1 和 nums2 的元素数量 ...

  6. Leetcode学习笔记（6）

    题目1 ID112 给定一个二叉树和一个目标和,判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和. 说明: 叶子节点是指没有子节点的节点. 示例: 给定如下二叉树,以及目标 ...

  7. Manacher算法学习笔记 | LeetCode#5

    Manacher算法学习笔记 DECLARATION 引用来源:https://www.cnblogs.com/grandyang/p/4475985.html CONTENT 用途:寻找一个字符串的 ...

  8. [Java] LinkedList / Queue - 源代码学习笔记

    简单地画了下 LinkedList 的继承关系,如下图.只是画了关注的部分,并不是完整的关系图.本博文涉及的是 Queue, Deque, LinkedList 的源代码阅读笔记.关于 List 接口 ...

  9. 学习笔记之机器学习（Machine Learning）

    机器学习 - 维基百科,自由的百科全书 https://zh.wikipedia.org/wiki/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0 机器学习是人工智能的一个分 ...

随机推荐

  1. java服务器部署开源项目（若依）

    1准备工作 (1)阿里云 centos_8_0_x64_20G_alibase_20200218.vhd [root@iZ2zeeqw5fxmm9zagf439aZ ~]# cat /etc/redh ...

  2. rbd的image快照与Pool快照

    前言 这个问题是不久前在ceph社区群里看到的,创建image的时候,当时的报错如下: 2016-12-13 23:13:10.266865 7efbfb7fe700 -1 librbd::image ...

  3. [原题复现][极客大挑战 2019]BuyFlag

    简介  原题复现:[极客大挑战 2019]BuyFlag  考察知识点:php函数特性(is_numeric().strcmp函数())  线上平台:https://buuoj.cn(北京联合大学公开 ...

  4. ubuntu16.04搭建vulhub环境

    简介 Vulhub官方中文教程https://github.com/vulhub/vulhub/blob/master/README.zh-cn.md 环境:ubuntu16.04.5 python3 ...

  5. 不是吧！做了两年java还没弄懂JVM堆？进来看看你就明白了

    堆的核心概述 一个JVM实例只存在一个堆内存,堆也是java内存管理的核心区域Java堆区在jvm启动的时候被创建,其空间大小也就确定了.是jvm管理的最大一块内存空间.(堆内存的大小可以调节)< ...

  6. 你了解ABBYY FineReader 14么？

    有没有一款是能够同时处理纸质文档和个类型PDF的一站式解决方案?答案是肯定的,ABBYY FineReader 14集合了强大的光学字符识别(OCR)以及 PDF 查看和编辑功能.不仅能够高效识别图片 ...

  7. 在CorelDRAW中如何完成属性的复制

    复制功能在任何一个编辑软件中都是必不可少.使用率很高的一个功能,在矢量图形设计软件CorelDRAW 中也不例外.关于对象的复制这里就不过多示意了,主要为大家示范一下如何在设计中复制对象的一些属性. ...

  8. 两种方式教你搞定在mac中格式化磁盘的问题

    mac怎么格式化u盘?想必这是大部分苹果用户都会关心的一个问题.格式化u盘在我们日常工作中算是一个比较常规的操作了.但是在mac中随着系统版本不一样,格式化的方式也略有差别.今天,小编将以Mac OS ...

  9. jQuery 第五章 实例方法 事件

    .on() .one() .off() .trigger() .click / keydown / mouseenter ...    .hover() ----------------------- ...

  10. 【Flask】学习笔记（一）入门

    Flask 入门基础 Flask是一个轻量级的后台框架,用Flask作为Web框架的公司有Netfix,Reddit等,国内豆瓣,果壳等.使用flask的公司列表.Flask 有主要的两个依赖,一个是 ...