def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
nodes = data.split(',')
value = nodes.pop(0)
if value == 'null':
return None
root = TreeNode(int(value))
queue = [root]
i = 1
while nodes:
tree_node = queue.pop(0)
value = nodes.pop(0)
if value == 'null':
tree_node.left = None
else:
tree_node.left = TreeNode(int(value))
value = nodes.pop(0)
if value == 'null':
tree_node.right = None
else:
tree_node.right = TreeNode(int(value))
if tree_node.left:
queue.append(tree_node.left)
if tree_node.right:
queue.append(tree_node.right)
return root
# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))
def test_129_sumNumbers(self):
root = TreeNode(4)
root.left = TreeNode(9)
root.right = TreeNode(0)
root.left.left = TreeNode(5)
root.left.right = TreeNode(1)
self.assertEqual(1026, self.solution._129_sumNumbers(root))
def test_112_hasPathSum(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
self.assertEqual(True, self.solution._112_hasPathSum(root, 11))
def test_111_minDepth(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
self.assertEqual(2, self.solution._111_minDepth(root))
def test_110_isBalanced(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.right = TreeNode(7)
self.assertTrue(self.solution._110_isBalanced(root))
root.right.right.right = TreeNode(8)
self.assertFalse(self.solution._110_isBalanced(root))
def allPossibleFBT(self, N):
if N == 1:
return [TreeNode(0)]
res = []
for i in range(1, N, 2):
for left_root, right_root in product(
self.allPossibleFBT(i), self.allPossibleFBT(N - 1 - i)):
root = TreeNode(0)
root.left, root.right = left_root, right_root
res.append(root)
return res
def __build_tree(table, menu, node_set, neighbor):
root = TreeNode(data=[])
for node in node_set:
pin = root
if node not in menu:
root.data.append(node)
continue
if not menu[node]:
root.data.append(node)
continue
for label in menu[node]:
for i in range(0, table[node][label]):
if label not in pin.children:
child = TreeNode(data=[])
pin.add_child(label, child)
pin = child
else:
pin = pin.children[label]
pin.data.append(node)
print("开始调整出入度树以最大化差异...")
print("开始调整出入度树以最大化差异...", file=statics.f_console)
# 梳理树中的目录信息, 并根据邻居信息将树中同一树节点上的点按照最大novelty间隔排开
q = CQueue()
q.put(root)
t_start_intervein = time.clock()
while not q.is_empty():
x_node = q.get()
__intervein_node(x_node.data, neighbor)
x_node.label_menu.sort()
for edge in x_node.children:
q.put(x_node.children[edge])
t_end_intervein = time.clock()
print("差异化出入度表耗时 " + str(t_end_intervein - t_start_intervein))
print("差异化出入度表耗时 " + str(t_end_intervein - t_start_intervein), file=statics.f_console)
print("开始计算prophecy...")
print("开始计算prophecy...", file=statics.f_console)
t_start_prophecy = time.clock()
__dfs_for_prophecy(root)
t_end_prophecy = time.clock()
print("计算prophecy耗时: " + str(t_end_prophecy - t_start_prophecy))
print("计算prophecy耗时: " + str(t_end_prophecy - t_start_prophecy), file=statics.f_console)
print("开始深先遍历出入度树...")
print("开始深先遍历出入度树...", file=statics.f_console)
statics.io_tree_max_dep = -1
dfs_for_depth(root, 1)
print("得到最大深度:" + str(statics.io_tree_max_dep))
print("得到最大深度:" + str(statics.io_tree_max_dep), file=statics.f_console)
return root
def trimBST1(self, root: 'TreeNode', L: int, R: int) -> 'TreeNode':
dummy = TreeNode(float('inf'))
dummy.left = root
print(root)
# default: cur is valid
def dfs(cur):
if not cur:
return
while cur.right and cur.right.val > R:
cur.right = cur.right.left
while cur.right and cur.right.val < L:
cur.right = cur.right.right
while cur.left and cur.left.val > R:
cur.left = cur.left.left
while cur.left and cur.left.val < L:
cur.left = cur.left.right
dfs(cur.left)
dfs(cur.right)
dfs(dummy)
return dummy.left
def bst_from_preorder(self, A):
if not A: return None
root = TreeNode(A[0])
i = bisect.bisect(A, A[0])
root.left = self.bst_from_preorder(A[1:i])
root.right = self.bst_from_preorder(A[i:])
return root
def build(stop):
if inorder and inorder[-1] != stop:
root = TreeNode(preorder.pop())
root.left = build(root.val)
inorder.pop()
root.right = build(stop)
return root
def recur(low, high):
if low > high: return None
x = TreeNode(postorder.pop())
mid = map_inorder[x.val]
x.right = recur(mid + 1, high)
x.left = recur(low, mid - 1)
return x
def buildTree(self, preorder, inorder):
if inorder:
idx = inorder.index(preorder.pop(0))
root = TreeNode(inorder[idx])
root.left = self.buildTree(preorder, inorder[0:idx])
root.right = self.buildTree(preorder, inorder[idx + 1:])
return root
def helper(self, node, val):
if node is None:
return TreeNode(val)
if val > node.val:
node.right = self.helper(node.right, val)
else:
node.left = self.helper(node.left, val)
return node
def f(self, inorder: list, postorder: list):
index = inorder.index(postorder[-1])
node = TreeNode(postorder[-1])
if index > 0:
node.left = self.f(inorder[:index], postorder[:index])
if index < len(inorder) - 1:
node.right = self.f(inorder[index + 1:], postorder[index:-1])
return node
def traverse(it):
v = next(it)
if v == "#":
return None
node = TreeNode(v)
node.left = traverse(it)
node.right = traverse(it)
return node
def f(self, nodes):
if len(nodes) == 0:
return [None]
if len(nodes) == 1:
return [TreeNode(nodes[0])]
else:
res = []
for index, n in enumerate(nodes):
left_nodes = self.f(nodes[:index])
right_nodes = self.f(nodes[index + 1:])
for i in left_nodes:
for j in right_nodes:
node = TreeNode(n)
node.left = i
node.right = j
res.append(node)
return res
def sortedArrayToBST(self, nums):
if not nums:
return None
mid = len(nums) // 2
root = TreeNode(nums[mid])
root.left = self.sortedArrayToBST(nums[:mid])
root.right = self.sortedArrayToBST(nums[mid + 1:])
return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if not nums:
return None
middle = len(nums) // 2
root = TreeNode(nums[middle])
root.left = self.sortedArrayToBST(nums[:middle])
root.right = self.sortedArrayToBST(nums[middle + 1:])
return root
def helper(i, j):
if i == j:
return None
root = TreeNode(A[i])
mid = bisect.bisect(A, A[i], i + 1, j)
root.left = helper(i + 1, mid)
root.right = helper(mid, j)
return root
def f(self, l: list):
mid = (len(l) - 1) // 2
node = TreeNode(l[mid])
if mid > 0:
node.left = self.f(l[:mid])
if mid < len(l) - 1:
node.right = self.f(l[mid + 1:])
return node
def buildTree(self, preorder: 'List[int]',
inorder: 'List[int]') -> 'TreeNode':
if not preorder:
return None
index = inorder.index(preorder[0])
root = TreeNode(preorder[0])
root.left = self.buildTree(preorder[1:index + 1], inorder[0:index])
root.right = self.buildTree(preorder[index + 1:], inorder[index + 1:])
return root
def mergeTrees(self, t1: 'TreeNode', t2: 'TreeNode') -> 'TreeNode':
if not t1 and not t2:
return None
t = TreeNode((t1.val if t1 else 0) + (t2.val if t2 else 0))
t.left = self.mergeTrees(t1.left if t1 else None,
t2.left if t2 else None)
t.right = self.mergeTrees(t1.right if t1 else None,
t2.right if t2 else None)
return t
def create_balanced_bst(values, n=None):
if values:
if n is None:
n = len(values)
m = n // 2
node = TreeNode(values[m], create_balanced_bst(values[:m], m),
create_balanced_bst(values[m + 1:], n - m - 1))
return node
else:
return None
def generate(first, last):
trees = []
for root in range(first, last + 1):
for left in generate(first, root - 1):
for right in generate(root + 1, last):
node = TreeNode(root)
node.left = left
node.right = right
trees += (node,)
return trees or [None]
def constructMaximumBinaryTree(self, nums):
if not nums:
return None
max_num = max(nums)
max_pos = nums.index(max_num)
node = TreeNode(max_num)
node.left, node.right = self.constructMaximumBinaryTree(
nums[:max_pos]), self.constructMaximumBinaryTree(nums[max_pos +
1:])
return node
def deserialize(self, data):
from queue import Queue
vals = data.split('\n')
root = None
if data:
root = TreeNode(int(vals[0]))
index = 1
q = Queue()
q.put(root)
while index < len(vals):
node = q.get()
if vals[index]:
node.left = TreeNode(int(vals[index]))
q.put(node.left)
if vals[index + 1]:
node.right = TreeNode(int(vals[index + 1]))
q.put(node.right)
index += 2
return root
def constructMaximumBinaryTree(self, nums):
index = nums.index(max(nums))
f_half = nums[:index]
s_half = nums[index + 1:]
node = TreeNode(nums[index])
if (len(f_half) > 0):
node.left = self.constructMaximumBinaryTree(f_half)
if (len(s_half) > 0):
node.right = self.constructMaximumBinaryTree(s_half)
return node
def mergeTrees(self, t1: 'TreeNode', t2: 'TreeNode') -> 'TreeNode':
if t1 is None:
return t2
if t2 is None:
return t1
root = TreeNode(t1.val + t2.val)
root.left = self.mergeTrees(t1.left, t2.left)
root.right = self.mergeTrees(t1.right, t2.right)
return root
def sortedArrayToBST(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
if not nums:
return None
mid = len(nums) // 2
node = TreeNode(nums[mid])
node.left = self.sortedArrayToBST(nums[:mid])
node.right = self.sortedArrayToBST(nums[mid + 1:])
return node
def deserialize(string):
if string == '{}':
return None
nodes = [None if val == 'null' else TreeNode(int(val))
for val in string.strip('[]{}').split(',')]
kids = nodes[::-1]
root = kids.pop()
for node in nodes:
if node:
if kids: node.left = kids.pop()
if kids: node.right = kids.pop()
return root