剑指offer分块总结----------树

1、重建二叉树

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre)==0:
            return None
        if len(pre)==1:
            return TreeNode(pre[0])
        root=TreeNode(pre[0])
        mid=tin.index(pre[0])
        root.left=self.reConstructBinaryTree(pre[1:mid+1],tin[:mid])
        root.right=self.reConstructBinaryTree(pre[mid+1:],tin[mid+1:])
        return root

2、二叉树的下一个结点

题目描述

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

# -*- coding:utf-8 -*-
# class TreeLinkNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#         self.next = None
class Solution:
    def GetNext(self, pNode):
        # write code here
        if not pNode:
            return None
        if not pNode.right and not pNode.left and not pNode.next:
            return None
        if pNode.right:
            res=pNode.right
            while res.left:
                res=res.left
            return res
        else:
            while pNode.next:
                if pNode.next.left==pNode:
                    return pNode.next
                pNode=pNode.next
            return None

3、对称的二叉树

题目描述

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def isSymmetrical(self, pRoot):
        # write code here
        if not pRoot:
            return True
        return self.marrior(pRoot.left,pRoot.right)
    def marrior(self,left,right):
        if not left and not right:#1
            return True
        if not left or not right:#2：1和2的位置千万不能颠倒
            return False
        if left.val==right.val:
            return self.marrior(left.left,right.right) and self.marrior(left.right,right.left)
        else:
            return False

4、按之字形顺序打印二叉树

题目描述

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Print(self, pRoot):
        # write code here
        if not pRoot:
            return []
        else:
            i=1
            l=[]
            res=[pRoot]
            while res:
                templist=[]
                tempres=[]
                for node in res:
                    tempres.append(node.val)
                    if node.left:
                        templist.append(node.left)
                    if node.right:
                        templist.append(node.right)
                res=templist
                if i%2==0:
                    tempres.reverse()
                i+=1
                l.append(tempres)
            return l

5、把二叉树打印成多行

题目描述

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if not pRoot:
            return []
        l=[]
        res=[pRoot]
        while res:
            templist=[]
            tempres=[]
            for node in res:
                tempres.append(node.val)
                if node.left:
                    templist.append(node.left)
                if node.right:
                    templist.append(node.right)
            res=templist
            l.append(tempres)
        return l

6、序列化二叉树

题目描述

请实现两个函数，分别用来序列化和反序列化二叉树

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。

序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。

二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

 

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Serialize(self, root):
        # write code here
        if not root:
            return '#'
        return str(root.val) +',' + self.Serialize(root.left) +','+ self.Serialize(root.right)
    def Deserialize(self, s):
        # write code here
        list = s.split(',')
        return self.deserializeTree(list)

    def deserializeTree(self, list):
        if len(list)<=0:
            return None
        val = list.pop(0)
        root = None
        if val != '#':
            root = TreeNode(int(val))
            root.left = self.deserializeTree(list)
            root.right = self.deserializeTree(list)
        return root

7、二叉搜索树的第k个结点

题目描述

给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8）    中，按结点数值大小顺序第三小结点的值为4。

 

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回对应节点TreeNode
    def KthNode(self, pRoot, k):
        # write code here
        if not pRoot or k<=0:
            return None
        node_stack=[]
        node=pRoot
        while node or node_stack:
            while node:
                node_stack.append(node)
                node=node.left
            node=node_stack.pop()
            k-=1
            if k==0:
                return node
            node=node.right
        return None

8、数据流中的中位数

题目描述

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。

如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

class Solution:
    def __init__(self):
        self.arr=[]
    def Insert(self, num):
        # write code here
        self.arr.append(num)
        self.arr.sort()
    def GetMedian(self,arr):
        # write code here
        lens=len(self.arr)
        if lens%2==1:
            return self.arr[lens//2]
        else:
            return (self.arr[lens//2]+self.arr[lens//2-1])/2.0