devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

蓝桥杯 第8天 树（2）_!leftnode

作者：盐析白兔 | 2024-04-19 13:27:49

赞

踩

!leftnode

目录

1.226. 翻转二叉树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归写法

（2）迭代之深度优先

（3）迭代之广度优先

2.101. 对称二叉树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归

（2）迭代

3.100. 相同的树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归

（2）迭代法

4.572. 另一棵树的子树 - 力扣（LeetCode） (leetcode-cn.com)

5.104. 二叉树的最大深度 - 力扣（LeetCode） (leetcode-cn.com)

（1）后序遍历（通过高度求深度）

（2）先序遍历（回溯法）（直接求深度）

（3）层序遍历

6.559. N 叉树的最大深度 - 力扣（LeetCode） (leetcode-cn.com)

7.111. 二叉树的最小深度 - 力扣（LeetCode） (leetcode-cn.com)

8.222. 完全二叉树的节点个数 - 力扣（LeetCode） (leetcode-cn.com)

（1）前序遍历

（2）完全二叉树的性质

9.110. 平衡二叉树 - 力扣（LeetCode） (leetcode-cn.com)

10.257. 二叉树的所有路径 - 力扣（LeetCode） (leetcode-cn.com)

11.​​​​​​404. 左叶子之和 - 力扣（LeetCode） (leetcode-cn.com)

（1）后序遍历

（2）层序遍历

12.513. 找树左下角的值 - 力扣（LeetCode） (leetcode-cn.com)

13.112. 路径总和 - 力扣（LeetCode） (leetcode-cn.com)

（1）深度优先搜索

14.113. 路径总和 II - 力扣（LeetCode） (leetcode-cn.com)

15.106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode） (leetcode-cn.com)

16.105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode） (leetcode-cn.com)

17.654. 最大二叉树 - 力扣（LeetCode） (leetcode-cn.com)

18.617. 合并二叉树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归

（2）迭代写法

1.226. 翻转二叉树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归写法

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def invertTree(self, root: TreeNode) -> TreeNode:
  9.         if root==None:
  10.             return None
  11.         root.left,root.right=root.right,root.left
  12.         self.invertTree(root.left)
  13.         self.invertTree(root.right)
  14.         return root

（2）迭代之深度优先

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def invertTree(self, root: TreeNode) -> TreeNode:
  9.         if root==None:
  10.             return None
  11.         stack=[root]
  12.         while stack:
  13.             top=stack.pop()
  14.             top.left,top.right=top.right,top.left
  15.             if top.left:
  16.                 stack.append(top.left)
  17.             if top.right:
  18.                 stack.append(top.right)
  19.         return root

（3）迭代之广度优先

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def invertTree(self, root: TreeNode) -> TreeNode:
  9.         if root==None:
  10.             return None
  11.         from collections import deque
  12.         que=deque([root])
  13.         while que:
  14.             top=que.popleft()
  15.             top.left,top.right=top.right,top.left
  16.             if top.left:
  17.                 que.append(top.left)
  18.             if top.right:
  19.                 que.append(top.right)
  20.         return root

2.101. 对称二叉树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def isSymmetric(self, root: TreeNode) -> bool:
  9.         return self.compare(root.left,root.right)
  10.  
  11.     def compare(self,left,right):
  12.         if left==None and right==None:return True
  13.         if left==None and right!=None:return False
  14.         if left!=None and right==None:return False
  15.         elif left.val!=right.val:return False
  16.  
  17.         x=self.compare(left.left,right.right)
  18.         y=self.compare(left.right,right.left)
  19.         return x and y

（2）迭代

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def isSymmetric(self, root: TreeNode) -> bool:
  9.         from collections import deque
  10.         que=deque([])
  11.         que.append(root.right)
  12.         que.append(root.left)
  13.         while que:
  14.             leftnode=que.popleft()
  15.             rightnode=que.popleft()
  16.             if leftnode==None and rightnode==None:
  17.                 continue
  18.             if not leftnode or not rightnode or leftnode.val != rightnode.val:
  19.                 return False
  20.             que.append(leftnode.left)
  21.             que.append(rightnode.right)
  22.             que.append(leftnode.right)
  23.             que.append(rightnode.left)
  24.         return True

3.100. 相同的树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归

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

（2）迭代法

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
  9.         from collections import deque
  10.         que=deque([])
  11.         que.append(q)
  12.         que.append(p)
  13.         while que:
  14.             x=que.popleft()
  15.             y=que.popleft()
  16.             if x==None and y==None:
  17.                 continue
  18.             if not x or not y or x.val!=y.val:
  19.                 return False
  20.             que.append(x.left)
  21.             que.append(y.left)
  22.             que.append(x.right)
  23.             que.append(y.right)
  24.         return True

4.572. 另一棵树的子树 - 力扣（LeetCode） (leetcode-cn.com)

有三种情况，一种是自己，一种是左孩子，一种是右孩子

一定要抽象起来

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def isSubtree(self, root: TreeNode, subRoot: TreeNode) -> bool:
  9.         if root==None:
  10.             return False
  11.         result1=self.compare(root,subRoot)
  12.         result2=self.isSubtree(root.left,subRoot)
  13.         result3=self.isSubtree(root.right,subRoot)
  14.         return result1 or result2 or result3
  15.  
  16.     def compare(self,x,y):
  17.         if x==None and y==None:
  18.             return True
  19.         if not x or not y or x.val!=y.val:
  20.             return False
  21.  
  22.         a=self.compare(x.left,y.left)
  23.         b=self.compare(x.right,y.right)
  24.         return a and b

5.104. 二叉树的最大深度 - 力扣（LeetCode） (leetcode-cn.com)

（1）后序遍历（通过高度求深度）

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def maxDepth(self, root: Optional[TreeNode]) -> int:
  9.         return self.getheight(root)
  10.  
  11.     def getheight(self,root):
  12.         if root==None:
  13.             return 0
  14.         lefth=self.getheight(root.left)
  15.         righth=self.getheight(root.right)
  16.         return max(lefth,righth)+1

（2）先序遍历（回溯法）（直接求深度）

python这边全局变量有点搞，最后只能通过一半的样例

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. result=0
  8. class Solution:
  9.     def maxDepth(self, root: Optional[TreeNode]) -> int:
  10.         if root==None:
  11.             return result
  12.         self.getheight(root,1)
  13.         return result
  14.  
  15.     def getheight(self,root,height):
  16.         global result
  17.         result=max(result,height)
  18.         if root.left==None and root.right==None:
  19.             return
  20.         if root.left:
  21.             self.getheight(root.left,height+1)
  22.         if root.right:
  23.             self.getheight(root.right,height+1)
  24.         return

（3）层序遍历

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. result=0
  8. class Solution:
  9.     def maxDepth(self, root: Optional[TreeNode]) -> int:
  10.         if root==None:
  11.             return 0
  12.         from collections import deque
  13.         que=deque([root])
  14.         ans=0
  15.         while que:
  16.             ans+=1
  17.             size=len(que)
  18.             for i in range(size):
  19.                 top=que.popleft()
  20.                 if top.left:
  21.                     que.append(top.left)
  22.                 if top.right:
  23.                     que.append(top.right)
  24.         return ans

6.559. N 叉树的最大深度 - 力扣（LeetCode） (leetcode-cn.com)

  1. """
  2. # Definition for a Node.
  3. class Node:
  4.     def __init__(self, val=None, children=None):
  5.         self.val = val
  6.         self.children = children
  7. """
  8.  
  9. class Solution:
  10.     def maxDepth(self, root: 'Node') -> int:
  11.         if root==None:
  12.             return 0
  13.         depth=0
  14.         for i in root.children:
  15.             depth=max(depth,self.maxDepth(i))
  16.         depth+=1
  17.         return depth

7.111. 二叉树的最小深度 - 力扣（LeetCode） (leetcode-cn.com)

注意理解题意，叶子节点

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def minDepth(self, root: TreeNode) -> int:
  9.         if root==None:
  10.             return 0
  11.         if root.left==None and root.right!=None:
  12.             return self.minDepth(root.right)+1
  13.         if root.left!=None and root.right==None:
  14.             return self.minDepth(root.left)+1
  15.         return 1+min(self.minDepth(root.left),self.minDepth(root.right))

8.222. 完全二叉树的节点个数 - 力扣（LeetCode） (leetcode-cn.com)

（1）前序遍历

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def countNodes(self, root: TreeNode) -> int:
  9.         return self.getnum(root)
  10.  
  11.     def getnum(self,root):
  12.         if root==None:
  13.             return 0
  14.         return 1+self.getnum(root.left)+self.getnum(root.right)

（2）完全二叉树的性质

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def countNodes(self, root: TreeNode) -> int:
  9.         if root==None:
  10.             return 0
  11.         left=root.left
  12.         right=root.right
  13.         leftnum=0
  14.         rightnum=0
  15.         while(left):
  16.             left=left.left
  17.             leftnum+=1
  18.         while(right):
  19.             right=right.right
  20.             rightnum+=1
  21.         if leftnum==rightnum:
  22.             return (2**(leftnum+1))-1
  23.         return 1+self.countNodes(root.left)+self.countNodes(root.right)

9.110. 平衡二叉树 - 力扣（LeetCode） (leetcode-cn.com)

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def isBalanced(self, root: TreeNode) -> bool:
  9.         a=self.getheight(root)
  10.         if a==-1:
  11.             return False
  12.         return True
  13.  
  14.     def getheight(self,root):
  15.         if root==None:
  16.             return 0
  17.         leftn=self.getheight(root.left)
  18.         rightn=self.getheight(root.right)
  19.         if leftn==-1:
  20.             return -1
  21.         if rightn==-1:
  22.             return -1
  23.         if abs(leftn-rightn)>1:
  24.             return -1
  25.         else:
  26.             return 1+max(leftn,rightn)

10.257. 二叉树的所有路径 - 力扣（LeetCode） (leetcode-cn.com)

注意回溯的细节

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def binaryTreePaths(self, root: TreeNode) -> List[str]:
  9.         result=[]
  10.         path=[]
  11.         if root==None:
  12.             return result
  13.         self.traversal(root,result,path)
  14.         return result
  15.  
  16.     def traversal(self,cur,result,path):
  17.         cur.val=str(cur.val)
  18.         path.append(cur.val)
  19.         if not cur.left and not cur.right:
  20.             ans="->".join(path)
  21.             result.append(ans)
  22.             return
  23.         if cur.left:
  24.             self.traversal(cur.left,result,path)
  25.             path.pop()
  26.         if cur.right:
  27.             self.traversal(cur.right,result,path)
  28.             path.pop()

11.​​​​​​404. 左叶子之和 - 力扣（LeetCode） (leetcode-cn.com)

（1）后序遍历

通过父节点来判断左节点是否为叶节点

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def sumOfLeftLeaves(self, root: TreeNode) -> int:
  9.         if root==None:
  10.             return 0
  11.         
  12.         leftsum=self.sumOfLeftLeaves(root.left)
  13.         rightsum=self.sumOfLeftLeaves(root.right)
  14.         midsum=0
  15.         if root.left and not root.left.left and not root.left.right:
  16.             midsum=root.left.val
  17.         return midsum+leftsum+rightsum

（2）层序遍历

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

12.513. 找树左下角的值 - 力扣（LeetCode） (leetcode-cn.com)

（1）前序遍历

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
  9.         maxlen=-1
  10.         leftvalue=0
  11.         def traversal(root,depth):
  12.             nonlocal maxlen,leftvalue
  13.             if root.left==None and root.right==None:
  14.                 if depth>maxlen:
  15.                     maxlen=depth
  16.                     leftvalue=root.val
  17.                 return
  18.             if root.left:
  19.                 traversal(root.left,depth+1)
  20.             if root.right:
  21.                 traversal(root.right,depth+1)
  22.             return
  23.         traversal(root,0)
  24.         return leftvalue

13.112. 路径总和 - 力扣（LeetCode） (leetcode-cn.com)

（1）深度优先搜索

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
  9.         if root==None:
  10.             return False
  11.  
  12.         def dfs(root,sums):
  13.             sums+=root.val
  14.             if root.left==None and root.right==None:
  15.                 if sums==targetSum:
  16.                     return True
  17.                 return False
  18.             if root.left:
  19.                 if dfs(root.left,sums):return True
  20.             if root.right:
  21.                 if dfs(root.right,sums):return True
  22.             return False
  23.         return dfs(root,0)

14.113. 路径总和 II - 力扣（LeetCode） (leetcode-cn.com)

深度优先搜索

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
  9.         result=[]
  10.         if root==None:
  11.             return result
  12.  
  13.         def dfs(root,sums,path):
  14.             nonlocal result
  15.             sums+=root.val
  16.             if root.left==None and root.right==None:
  17.                 if sums==targetSum:
  18.                     result.append(path+[root.val])
  19.                 return
  20.  
  21.             if root.left:
  22.                 dfs(root.left,sums,path+[root.val])
  23.             if root.right:
  24.                 dfs(root.right,sums,path+[root.val])
  25.         dfs(root,0,[])
  26.         return result

15.106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode） (leetcode-cn.com)

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
  9.         if not postorder:
  10.             return None
  11.         rootnode=postorder[-1]
  12.  
  13.         root=TreeNode(rootnode)
  14.         cut=inorder.index(rootnode)
  15.         inlefttree=inorder[:cut]
  16.         inrighttree=inorder[cut+1:]
  17.         postlefttree=postorder[:len(inlefttree)]
  18.         postrighttree=postorder[len(inlefttree):-1]
  19.         root.left=self.buildTree(inlefttree,postlefttree)
  20.         root.right=self.buildTree(inrighttree,postrighttree)
  21.         return root

16.105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode） (leetcode-cn.com)

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
  9.         if not preorder:
  10.             return None
  11.         
  12.         rootnode=preorder[0]
  13.  
  14.         cut=inorder.index(rootnode)
  15.         leftinorder=inorder[:cut]
  16.         rightinorder=inorder[cut+1:]
  17.  
  18.         leftpreorder=preorder[1:1+len(leftinorder)]
  19.         rightpreorder=preorder[1+len(leftinorder):]
  20.  
  21.         root=TreeNode(rootnode)
  22.         root.left=self.buildTree(leftpreorder,leftinorder)
  23.         root.right=self.buildTree(rightpreorder,rightinorder)
  24.         return root

17.654. 最大二叉树 - 力扣（LeetCode） (leetcode-cn.com)

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

18.617. 合并二叉树 - 力扣（LeetCode） (leetcode-cn.com)

（1）递归

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

（2）迭代写法

  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
  9.         if not root1:
  10.             return root2
  11.         if not root2:
  12.             return root1
  13.         from collections import deque
  14.         que=deque([])
  15.         que.append(root1)
  16.         que.append(root2)
  17.         while que:
  18.             node1=que.popleft()
  19.             node2=que.popleft()
  20.  
  21.             if node1.left and node2.left:
  22.                 que.append(node1.left)
  23.                 que.append(node2.left)
  24.             if node1.right and node2.right:
  25.                 que.append(node1.right)
  26.                 que.append(node2.right)
  27.             node1.val+=node2.val
  28.             if not node1.left and node2.left:
  29.                 node1.left=node2.left
  30.             if not node1.right and node2.right:
  31.                 node1.right=node2.right
  32.         return root1
  1. # Definition for a binary tree node.
  2. # class TreeNode:
  3. #     def __init__(self, val=0, left=None, right=None):
  4. #         self.val = val
  5. #         self.left = left
  6. #         self.right = right
  7. class Solution:
  8.     def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
  9.         if not root1:
  10.             return root2
  11.         if not root2:
  12.             return root1
  13.         from collections import deque
  14.         que=[]
  15.         que.append(root2)
  16.         que.append(root1)
  17.         while que:
  18.             node1=que.pop()
  19.             node2=que.pop()
  20.  
  21.             if node1.left and node2.left:
  22.                 que.append(node2.left)
  23.                 que.append(node1.left)
  24.             if node1.right and node2.right:
  25.                 que.append(node2.right)
  26.                 que.append(node1.right)
  27.             node1.val+=node2.val
  28.             if not node1.left and node2.left:
  29.                 node1.left=node2.left
  30.             if not node1.right and node2.right:
  31.                 node1.right=node2.right
  32.         return root1

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/451902
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号