def convert(self, tokens):
stack = []
for token in tokens:
if token in self.OPERANDS:
operands_count = self.OPERANDS.get(token)
node = TreeNode(token)
if operands_count == 1:
node.left = stack.pop()
else:
node.right = stack.pop()
node.left = stack.pop()
stack.append(node)
else:
stack.append(TreeNode(token))
return node
def main():
solver = Solution()
root = TreeNode(1)
root.left = TreeNode(2)
root.left.left = TreeNode(3)
print(solver.maxPathSum(root))
def operate_tn(op, l, r):
if op == ":": #':' operator adds the length of branch (and create node if no node exists)
if isinstance(l, TreeNode):
l.length = float(r)
return l
else:
nod = TreeNode(name=[l], length=float(
r)) #added [] 18/10/13...to give all tip names as node.name
return nod
elif op == ",": #',' operator creat a subtree from 2 nodes
if not isinstance(l, TreeNode):
l = TreeNode(name=[
l
]) #added [] 18/10/13...to give all tip names as node.name
if not isinstance(r, TreeNode):
r = TreeNode(name=[
r
]) #added [] 18/10/13...to give all tip names as node.name
nod = TreeNode(
name=l.name + r.name
) #added [] 18/10/13...to give all tip names as node.name. need refactoring.
l.parent = nod
r.parent = nod
nod.left, nod.right = l, r
return nod
def merge_two_trees_dfs(root1: TreeNode, root2: TreeNode) -> TreeNode:
""" DFS / Recursion
We can traverse the two trees from root node at the same time using DFS,
and merge corresponding nodes. There are three cases:
1. Both of the two nodes are empty, then the merged one will be empty as
well.
2. If there is only one node is empty, then the non-empty node will be
the merged node.
3. If both nodes are non-empty, then we shall calculate the sum of the
two nodes' values to merge them.
Time Complexity - O(min(M, N)) - M, N are the number of nodes for the
two trees.
Space Complexity - O(1) - If operating on the original tree such as
root1, then it's constant, otherwise, O(min(M,N)).
"""
# Edge cases, rooot1 or root2 is None.
if not root1: return root2
if not root2: return root1
# Otherwise, root1 and root2 both exist, update the value and dive into
# left and right node. After the two edge cases, it's equivalent to
# if root1 and root2:
root1.val += root2.val
root1.left = merge_two_trees_dfs(root1.left, root2.left)
root1.right = merge_two_trees_dfs(root1.right, root2.right)
return root1
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
if not t1 or not t2:
return t1 or t2
t1.val = t1.val + t2.val
t1.left = self.mergeTrees(t1.left, t2.left)
t1.right = self.mergeTrees(t1.right, t2.right)
return t1
def doit():
val = next(vals)
if val == '#':
return None
node = TreeNode(int(val))
node.left = doit()
node.right = doit()
return node
def tree_build_left_linked_list(data):
if data:
node = TreeNode(data[0])
next_node = tree_build_left_linked_list(data[1:])
node.left = next_node
return node
else:
return None
def buildTree(self, preorder, inorder) -> TreeNode:
if not preorder or not inorder:
return
root = TreeNode(preorder[0]) #先根
idx = inorder.index(preorder[0]) #中
root.left = self.buildTree(preorder[1:1 + idx], inorder[:idx])
root.right = self.buildTree(preorder[1 + idx:], inorder[idx + 1:])
return root
def sorted_list_to_tree(numbers):
middle = len(numbers) // 2
root = None
if middle >= 0 and middle < len(numbers):
root = TreeNode(numbers[middle])
root.left = sorted_list_to_tree(numbers[0:middle])
root.right = sorted_list_to_tree(numbers[middle+1:])
return root
def create_tree(array, start, end):
if end < start:
return None
mid = int((start + end) / 2)
mid_node = TreeNode(array[mid])
mid_node.left = create_tree(array, start, mid - 1)
mid_node.right = create_tree(array, mid + 1, end)
return mid_node
def test_minimal_tree_simple(self):
expected = TreeNode(2)
expected.left = TreeNode(1)
expected.right = TreeNode(3)
self.assertEqual(
minimal_tree([1, 2, 3]),
expected
)
def build_tree(preorder, inorder):
if not inorder:
return None
root_val = preorder.pop(0)
idx = inorder.index(root_val)
root = TreeNode(root_val)
root.left = build_tree(preorder, inorder[:idx])
root.right = build_tree(preorder, inorder[idx + 1:])
return root
def main():
root = TreeNode(12)
root.left = TreeNode(7)
root.right = TreeNode(1)
root.left.left = TreeNode(9)
root.right.left = TreeNode(10)
root.right.right = TreeNode(5)
print(print_path(find_paths(root, 23)))
print(print_path(find_paths(root, 16)))
def build(start, end):
if end < start:
return
mid = math.ceil((end - start) / 2) + start
root = TreeNode(input[mid])
root.left = build(start, mid - 1)
root.right = build(mid + 1, end)
return root
def buildTreeR(self, inorder, postorder):
""" Recursive"""
if not inorder or not postorder:
return None
root = TreeNode(postorder.pop())
index = inorder.index(root.val)
# Its right first, as the pop order is postorder - root, right, left
root.right = self.buildTree(inorder[index + 1:], postorder)
root.left = self.buildTree(inorder[:index], postorder)
return root
def buildHelper(self, preorder, inorder):
if not preorder or not inorder:
return None
root = TreeNode(preorder.popleft())
index = inorder.index(root.val)
root.left = self.buildHelper(preorder, inorder[:index])
root.right = self.buildHelper(preorder, inorder[index + 1:])
return root
def dfs(dq):
if not dq:
return None
node = dq.popleft()
if node == '#':
return None
root = TreeNode(int(node))
root.left = dfs(dq)
root.right = dfs(dq)
return root
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder or not inorder:
return
rootVal = preorder.pop(0)
root = TreeNode(rootVal)
index = inorder.index(rootVal)
leftIn = inorder[:index]
rightIn = inorder[index + 1:]
root.left = self.buildTree(preorder, leftIn)
root.right = self.buildTree(preorder, rightIn)
return root
def trim(node: TreeNode):
if not node:
return None
if node.val < low:
return trim(node.right)
if node.val > high:
return trim(node.left)
node.left = trim(node.left)
node.right = trim(node.right)
return node
def tree_build_left_linked_list(data):
if data:
# similar to building a linked list just .next is replaced with .left. If there
# are any elements we create a node with the first value then set its child to
# the return of this fuction without the first value
node = TreeNode(data[0])
next_node = tree_build_left_linked_list(data[1:])
node.left = next_node
return node
else:
return None
def build_bracket_tree(bracket_depth, players):
new_node = TreeNode()
if bracket_depth == 1:
new_node.player_one = players.pop()
new_node.player_two = players.pop()
# TODO(ericslchiang): Fix seeding later, for now fill in order
else:
new_node.left = build_bracket_tree(bracket_depth - 1, players)
new_node.right = build_bracket_tree(bracket_depth - 1, players)
return new_node
def train(self, data, labels, remaining_depth=None, k=None):
"""
Grows a decision tree by constructing nodes. Greedily sets split rules for each node by maximizing
information gain.
Stops growing (either when no training datapoints are left to separate or when max depth is reached)
and inserts a leaf node.
Stores the root node of the resulting tree to use as a starting point for classification later.
Parameters
----------
data : np.array
An (n, d) numpy matrix with numerical (float or int) entries. Each row represents a datapoint.
labels : np.array
An (n,) numpy array. Each entry represents the label for its corresponding datapoint.
remaining_depth : int, optional
The number of children that can be created underneath nodes at this level of recursion.
Should be None on the first call.
k : int, optional
The number of possible labels. If set to None, the first call to this function will assign it.
TODO: change the assumption that labels only take on values 0, 1, ..., k - 1.
"""
node = TreeNode(None, None, None, None)
if remaining_depth is None:
# Bookkeeping for first call
if k is None:
k = np.max(labels) + 1
remaining_depth = self.max_depth
self.root_node = node
self.set_possible_threshold_values(data)
if remaining_depth > 0:
# Non-leaf case
node.split_rule = self.find_best_split_rule(data, labels)
left_data, left_labels, right_data, right_labels = self.split_data_and_labels(
data, labels, node.split_rule)
if len(left_data) == 0 or len(right_data) == 0:
# If there would be no more data to split in one of the child nodes, make a leaf
node.convert_to_leaf(labels, k)
else:
node.left = self.train(left_data, left_labels, remaining_depth - 1, k)
node.right = self.train(right_data, right_labels, remaining_depth - 1, k)
else:
# If we've reached our max depth, make a the node a leaf
node.convert_to_leaf(labels, k)
return node
def _reassign(self, parent: TreeNode, node: Inode,
new_node: TreeNode) -> None:
"""
Mutate the value of a child node, given parent node, child node and its new value
Note: parent can be Empty, in the case that node in root
"""
if (isinstance(parent, Empty)):
self.root = new_node
else:
if self._is_right(node, parent):
parent.right = new_node
else:
parent.left = new_node
def buildTree(self, preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
if not inorder:
return None
root_val = preorder[0]
root = TreeNode(root_val)
mid = inorder.index(root_val)
root.left = self.buildTree(preorder[1:mid + 1], inorder[:mid])
root.right = self.buildTree(preorder[mid + 1:], inorder[mid + 1:])
return root
def make_tree(start_index, end_index): # 只和长度有关
# 首先判定我们的区间是否合理，即left_index要<=right_index
# 当相等时，只有root会产生，不会产生左右小树
if start_index > end_index:
return None
# 我这里变量名都写得比较长，目的是方便理解
mid_index = (start_index + end_index) // 2
this_tree_root = TreeNode(nums[mid_index]) # 做一个小树的root
this_tree_root.left = make_tree(start_index, mid_index - 1)
this_tree_root.right = make_tree(mid_index + 1, end_index)
return this_tree_root # 做好的小树
def rebuilt_binary_tree(pre, ino):
"""前序遍历和中序遍历确定二叉树"""
if not pre and not ino:
return None
root = TreeNode(pre[0])
if set(pre) != set(ino):
return None
i = ino.index(pre[0])
root.left = rebuilt_binary_tree(pre[1:i+1], ino[:i])
root.right = rebuilt_binary_tree(pre[i+1:], ino[i+1:])
return root
def deserialize(self, s):
"""前序遍历序列转化为二叉树"""
self.flag += 1
l = s.split(',')
if self.flag >= len(s):
return None
root = None
if l[self.flag] != '#':
root = TreeNode(int(l[self.flag]))
root.left = self.deserialize(s)
root.right = self.deserialize(s)
return root
def _recurs_insert(self, node: TreeNode, data: any) -> bool:
if node.value == data:
return False
if data > node.value:
if isinstance(node.right, Empty):
node.right = Inode(data)
return True
else:
return self._recurs_insert(node.right, data)
elif data < node.value:
if isinstance(node.left, Empty):
node.left = Inode(data)
return True
else:
return self._recurs_insert(node.left, data)
return False
def dp(nums: List[int]) -> List[Optional[TreeNode]]:
if len(nums) == 0:
return [None]
if len(nums) == 1:
return [TreeNode(nums[0])]
ret = []
for i in range(len(nums)):
left_list = dp(nums[:i])
right_list = dp(nums[i + 1:])
for left, right in itertools.product(left_list, right_list):
root = TreeNode(nums[i])
root.left = left
root.right = right
ret.append(root)
return ret
def buildTree(preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
if len(preorder) == 0 and len(inorder) == 0:
return None
root = TreeNode(preorder[0])
root_ind = inorder.index(preorder[0])
left_inorder = inorder[:root_ind]
right_inorder = inorder[root_ind + 1:]
left_preorder = [i for i in preorder if i in left_inorder]
right_preorder = [i for i in preorder if i in right_inorder]
root.left = buildTree(left_preorder, left_inorder)
root.right = buildTree(right_preorder, right_inorder)
return root
def deserialize_tree(tree_data : list):
"""
Decodes your encoded data to tree.
:type data: list
:rtype: TreeNode
"""
value = tree_data.pop(0)
if value == [None]:
return None
root = TreeNode()
root.val = value
root.left = deserialize_tree(tree_data)
root.right = deserialize_tree(tree_data)
return root
q.put(current.left)
if current.right != None:
q.put(current.right)
return list
s = Solution()
t1 = TreeNode(1)
t2 = TreeNode(2)
t3 = TreeNode(3)
t4 = TreeNode(4)
t5 = TreeNode(5)
t6 = TreeNode(6)
t7 = TreeNode(7)
t1.left = t2
t1.right = t3
t2.left = t4
t2.right = t5
t3.left = t6
t3.right = t7
level_order_list = s.levelOrder(t1)
for node in level_order_list:
print(node, end=" ")
