二叉树的相关在线编程（python）

问题一：

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

正确的后序遍历结果：

sequence = [37, 35, 51, 47, 59, 73, 93, 98, 87, 61]

python源码：

 class Solution:
     def VerifySquenceOfBST(self, sequence):
         # write code here
         if sequence == None or len(sequence) == 0:
             return False
         length = len(sequence)
         root = sequence[length - 1]
 
         # 在二叉搜索 树中 左子树节点小于根节点   （应该是二叉排序树）
         for i in range(length):  # 获得左右的分叉口
             if sequence[i] > root:
                 break
 
         # 二叉搜索树中右子树的节点都大于根节点
         for j in range(i, length):
             if sequence[j] < root:
                 return False
 
         # 判断左子树是否为二叉树
         left = True
         if i > 0:
             left = self.VerifySquenceOfBST(sequence[0:i])
 
         # 判断 右子树是否为二叉树
         right = True
         if i < length - 1:
             right = self.VerifySquenceOfBST(sequence[i:-1])
 
         return left and right
 
 if __name__ == '__main__':
     s = Solution()
     # sequence = [37, 35, 51, 47, 59, 73, 93, 98, 61, 87]   # 错误的二叉排序树的后续遍历
     sequence = [37, 35, 51, 47, 59, 73, 93, 98, 87, 61]     # 正确的二叉排序树的后续遍历
     print(s.VerifySquenceOfBST(sequence))

问题二：

　　

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

 class TreeNode:
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None
 
 class Solution:
     def HasSubtree(self, pRoot1, pRoot2):  # 判断是否有子树
         if pRoot1 == None or pRoot2 == None:
             return False
 
         result = False
         if pRoot1.val == pRoot2.val:  # 根节点相等，进行下一步
             result = self.IsSubtree(pRoot1, pRoot2) # 判断子节点是否“相等”
 
         if result == False:
             res1 = self.HasSubtree(pRoot1.left, pRoot2)
             res2 = self.HasSubtree(pRoot1.right, pRoot2)
             result = res1 or res2
 
         return result
 
     def IsSubtree(self, pRoot1, pRoot2):
         if pRoot2 == None:
             return True
         if pRoot1 == None:
             return False
         if pRoot1.val == pRoot2.val:
             leftt = self.IsSubtree(pRoot1.left, pRoot2.left)
             rightt = self.IsSubtree(pRoot1.right, pRoot2.right)
             return leftt and rightt
         return False
 
     def getBSTwithPreTin(self, pre, tin):  # 最终确定树的形状，使用object的形式存储
         if len(pre) == 0 | len(tin) == 0:  # 任何一个为空树，则返回空
             return None  # 直接跳出代码
         root = TreeNode(pre[0])  # 前序遍历直接找到根节点(第一个元素就是根节点)
         for i, item in enumerate(tin):  # 序号和元素，将中序遍历拆分成左右两支
             if root.val == item:
                 root.left = self.getBSTwithPreTin(pre[1:i + 1], tin[:i])
                 root.right = self.getBSTwithPreTin(pre[i + 1:], tin[i + 1:])
                 return root
 
 if __name__ == '__main__':
     solution = Solution()
 
     preorder_seq = [1, 2, 4, 7, 3, 5, 6, 8]  # 前序遍历
     middleorder_seq = [4, 7, 2, 1, 5, 3, 8, 6]  # 中序遍历
     treeA = solution.getBSTwithPreTin(preorder_seq, middleorder_seq)
 
     preorder_seq = [1, 2, 3]
     middleorder_seq = [2, 1, 3]
     treeB = solution.getBSTwithPreTin(preorder_seq, middleorder_seq)
 
     print(solution.HasSubtree(treeA, treeB))