python 重建二叉树与二叉树下一个节点

本程序包括2个部分：

1，剑指offer第7题：重建二叉树

给定一个前序与中序遍历序列，重新构建二叉树，并且输出它根节点

2，剑指offer第8题：二叉树的下一个节点

给定一个树所有节点的父节点，左右节点，找出指定节点的在中序遍历序列中的下一个节点

# _*_encoding:utf-8 _*_

class TreeNode:
"""
建立二叉树节点的属性
"""
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
        # parent 在第一题中不需要用到
        # 为了方便第二题，在重建的时候把父节点也找出来
        self.parent = None

    class Solution:
        def reconstruct_tree(self, pre, mid, parent=None):
        """
        重建二叉树
        前序遍历序列确定一个根节点，中序遍历确定左右子树，采用迭代
        """
            if len(pre) == 0:
                return None
            else:
                res = TreeNode(pre[0])
                res.parent = parent
                res.left = self.reconstruct_tree(pre[1: mid.index(pre[0]) + 1], 
                                                    mid[: mid.index(pre[0])],res)
                res.right = self.reconstruct_tree(pre[mid.index(pre[0]) + 1: ], 
                                                    mid[mid.index(pre[0]) + 1:],res)
            return res


        def get_next_node(self, node):
        """
        获取下一个节点
        """
            if not node:
                return None
            if node.right:
            # 如果存在有右节点，那么下一个节点就是右子树的最左节点
                node = node.right
                while node.left:
                    node = node.left
                return node
            elif node.parent:
            # 如果存在父节点
            # 下一个节点一直向上遍历，直到找到一个节点是另外一个节点的左节点，
            # 或者遍历到达根节点了，那么不存在下一个节点
                while node.parent and node.parent.right == node:
                    # 循环向上遍历，只到找到不是某个节点的右节点或者到达根节点
                    # 情况1：一个节点是父节点的左节点，那么下一个节点是这个父节点
                    # 情况2: 达到根节点，根节点的父节点为None
                    node = node.parent
                return node.parent
            # 否则不存在下一个节点
            return None

# 下面的在类外面的函数 
def print_node(node):
"""
这个函数可以不要，只是为了输出所有节点的父节点，左右节点
"""
    print 'value:', node.val
    if node.parent:
        print 'The parent node value', node.parent.val,
    if node.left:
        print 'The left_node:', node.left.val,
    if node.right:
        print 'The right_node:', node.right.val,
    print '\n--------------------------------'
    if node.left:
        print_node(node.left)
    if node.right:
        print_node(node.right)
    return None


def post_lst(node, state=()):
"""
输入根节点，输出后序遍历
"""
    if node.left:
        state = post_lst(node.left, state)
    if node.right:
        state = post_lst(node.right, state)
    state = state+(node.val,)
    return state


def find_node(node, val):
"""
这个函数功能：
输入某个数字，会返回这是数字的对应的节点
只是为了方便做“下一个节点”的测试
"""
    if node.val == val:
        return node
    else:
        if node.left:
            snode = find_node(node.left, val)
            if snode:
               return snode
        if node.right:
            snode = find_node(node.right, val)
            if snode:
               return snode
        return None

测试用例：
pre = [1,2,4,7,3,5,6,8]#前序遍历序列
mid = [4,7,2,1,5,3,8,6]#中序遍历序列

solution = Solution()
node = solution.reconstruct_tree(pre,mid)#重建二叉树
# 输出后序遍历序列
print post_lst(node)
# 找到数字7这个节点
snode = find_node(node,7)
# 找到指定节点的下一个节点
next_node = solution.get_next_node(snode) 
# 输出下一个节点
if next_node:
    print next_node.val