题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
# -*- coding:utf-8 -*-
# class TreeNode:
# 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 not pre:
return None
elif len(pre) == 1:
return TreeNode(pre[0])
else:
root = TreeNode(pre[0])
root.left = self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1], tin[:tin.index(pre[0])])
root.right = self.reConstructBinaryTree(pre[tin.index(pre[0])+1:], tin[tin.index(pre[0])+1:])
return root
题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
# -*- 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 pNode.right:
pNode = pNode.right
while pNode.left:
pNode = pNode.left
return pNode
while pNode.next:
p = pNode.next
if pNode == p.left:
return p
pNode = p
return None
题目描述
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
# -*- coding:utf-8 -*-
# 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.comTree(pRoot.left, pRoot.right)
def comTree(self, left, right):
if not left and not right:
return True
if not left or not right:
return False
if left.val == right.val:
return self.comTree(left.left, right.right) and self.comTree(left.right, right.left)
else:
return False
题目描述
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
# -*- coding:utf-8 -*-
# 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 []
res = []
stack = [pRoot]
left_right = False
while stack:
tmp = []
tmpres = []
for i in stack:
tmpres.append(i.val)
if i.left:
tmp.append(i.left)
if i.right:
tmp.append(i.right)
if left_right:
tmpres = tmpres[::-1]
if tmpres:
res.append(tmpres)
left_right = not left_right
stack = tmp
return res
题目描述
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
# -*- coding:utf-8 -*-
# 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 []
res = []
current = [pRoot]
while current:
tmp = []
restmp = []
for i in current:
restmp.append(i.val)
if i.left:
tmp.append(i.left)
if i.right:
tmp.append(i.right)
current = tmp
res.append(restmp)
return res
题目描述
请实现两个函数，分别用来序列化和反序列化二叉树
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
import re
class Solution:
def __init__(self):
self.flag = -1
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
self.flag += 1
L = re.split(',|!', s)
if self.flag > len(L):
return None
root = None
while L[self.flag] != '#':
root = TreeNode(int(L[self.flag]))
root.left = self.Deserialize(s)
root.right = self.Deserialize(s)
return root
题目描述
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
# -*- coding:utf-8 -*-
# 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 k < 0:
return None
count = 0
tmp = []
while tmp or pRoot:
if pRoot:
tmp.append(pRoot)
pRoot = pRoot.left
else:
pRoot = tmp.pop()
count += 1
if count == k:
return pRoot
pRoot = pRoot.right
return None
题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
# -*- coding:utf-8 -*-
import heapq
class Solution:
def __init__(self):
self.count = 0
self.minheap = []
self.maxheap = []
def Insert(self, num):
# write code here
self.count += 1
if self.count&1 :
heapq.heappush(self.minheap, num)
min_heap_top = heapq.heappop(self.minheap)
heapq.heappush(self.maxheap, -min_heap_top)
else:
heapq.heappush(self.maxheap, -num)
max_heap_top = heapq.heappop(self.maxheap)
heapq.heappush(self.minheap, -max_heap_top)
def GetMedian(self, s):
# write code here
if self.count&1:
return -self.maxheap[0]
else:
return (self.minheap[0] - self.maxheap[0])/2.0
