二叉树的操作

重建二叉树

• 问题：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重 复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

• 解决：

  #递归一
  # class TreeNode:
  #     def __init__(self, x):
  #         self.val = x
  #         self.left = None
  #         self.right = None
  class Solution:
      def reConstructBinaryTreeCore(self,pre,pre_start,pre_end,tin,tin_start,tin_end):
          if pre_start > pre_end or tin_start > tin_end:
              return None
          root = TreeNode(pre[pre_start])
          for i in range(tin_start,tin_end+1):
              if pre[pre_start] == tin[i]:
                  root.left = self.reConstructBinaryTreeCore(pre,pre_start+1,i-tin_start+pre_start,tin,tin_start,i-1)
                  root.right = self.reConstructBinaryTreeCore(pre,i-tin_start+pre_start+1,pre_end,tin,i+1,tin_end)
                  break
          return root
      # 返回构造的TreeNode根节点
      def reConstructBinaryTree(self, pre, tin):
          # write code here
          if len(pre)==0 or len(tin)==0:
              return None
          return self.reConstructBinaryTreeCore(pre,0,len(pre)-1,tin,0,len(tin)-1)
  #递归二
  class Solution:
      # 返回构造的TreeNode根节点
      def reConstructBinaryTree(self, pre, tin):
          # write code here
          if not pre or not tin:
              return
          root = TreeNode(pre[0])
          i = tin.index(pre[0])
          root.left =  self.reConstructBinaryTree(pre[1:i+1], tin[:i])
          root.right = self.reConstructBinaryTree(pre[i+1:], tin[i+1:])
          return root
  

二叉树的遍历

• 问题：输入两棵二叉树A，B，判断B是不是A的子结构。（约定空树不是任意一个树的子结构）

• 解决：

  #递归
  class Solution:
      def isSame(self, begin: TreeNode, beginSub: TreeNode):
          if not beginSub:
              return True
          if not begin or begin.val != beginSub.val:
              return False
          return self.isSame(begin.left, beginSub.left) and self.isSame(begin.right, beginSub.right)
      def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:
          if not A or not B:
              return False
          result = False
          if A.val == B.val:
              result = self.isSame(A, B)
          if not result:
              result = self.isSubStructure(A.left,B)
          if not result:
              result = self.isSubStructure(A.right,B)
          return result
  #优化
  class Solution:
      def HasSubtree(self, A, B):
          # write code here
          def recur(A, B):
              if not B: return True
              if not A or A.val != B.val: return False
              return recur(A.left, B.left) and recur(A.right, B.right)
  
          return bool(A and B) and (recur(A, B) or self.HasSubtree(A.left, B) or self.HasSubtree(A.right, B))
  
  

二叉树的镜像

• 问题：操作给定的二叉树，将其变换为源二叉树的镜像。

• 解决：

  #递归
  class Solution:
      # 返回镜像树的根节点
      def Mirror(self, root):
          # write code here
          if not root:
              return
          temp = root.left
          root.left, root.right= root.right, root.left
          self.Mirror(root.left)
          self.Mirror(root.right)
          return root
  #辅助栈
  class Solution:
      # 返回镜像树的根节点
      def Mirror(self, root):
          if not root: return
          stack = [root]
          while stack:
              node = stack.pop()
              if node.left: stack.append(node.left)
              if node.right: stack.append(node.right)
              node.left,node.right = node.right,node.left
          return root
  
  

从上到下打印二叉树

• 问题：从上往下打印出二叉树的每个节点，同层节点从左至右打印。

• 解决：

  class Solution:
      def PrintFromTopToBottom(self, root):
          #判断是否为空
          if not root:return []
          queue, res = [], []
          queue.append(root)
          while queue:
              node = queue.pop(0)
              res.append(node.val)
              if node.left:queue.append(node.left)
              if node.right:queue.append(node.right)
          return res
  

二叉搜索树的后序遍历序列（BST特征的理解）

• 问题：输入一个非空整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输 入的数组的任意两个数字都互不相同。

• 解决：

  class Solution:
      def Helper(self, sequence, start, end):
          if start >= end:
              return True
          root = sequence[end]
          i = start
          while i <= end and sequence[i] < root:
              i += 1
          for j in range(i,end):
              if sequence[j] < root:
                  return False
          #[start,i,end]
          return self.Helper(sequence, start, i-1) and self.Helper(sequence, i, end-1)
      def VerifySquenceOfBST(self, sequence):
          # write code here
          if not sequence or len(sequence)==0:
              return False
          return self.Helper(sequence, 0, len(sequence)-1)