def recoverFromPreorder(self, S: str) -> TreeNode:
if not S:
return None
S += '-' # 加一个字符保证最后一个节点也能入栈
stack = [] # 节点堆栈
lvl, val = 0, None
for c in S:
if c.isdigit():
if val is None:
val = 0
val = val * 10 + int(c)
else:
if val != None: # 节点入栈
if stack:
top, topLvl = stack[-1]
while topLvl >= lvl:
stack.pop()
top, topLvl = stack[-1]
node = TreeNode(val)
if top.left:
top.right = node
else:
top.left = node
stack.append((node, lvl))
else:
stack.append((TreeNode(val), lvl))
lvl, val = 0, None # 入栈之后重置
lvl += 1 # 层级加1
return stack[0][0]
def testFromList():
lst = [1, 2, 3, 4, '#', '#', 5]
expect = TreeNode(1,
left=TreeNode(2, left=TreeNode(4)),
right=TreeNode(3, right=TreeNode(5)))
assert str(fromList(lst)) == str(expect)
assert fromList([]) == None
def create_tree_1():
"""
A
+-B
| +-C
| \-D
\-E
+-F
| \-G
\-H
\-I
\-J
:return: TreeNode A
"""
a = TreeNode("A")
b = TreeNode("B")
c = TreeNode("C")
d = TreeNode("D")
e = TreeNode("E")
f = TreeNode("F")
g = TreeNode("G")
h = TreeNode("H")
i = TreeNode("I")
j = TreeNode("J")
a.add_node(b)
a.add_node(e)
b.add_node(c)
b.add_node(d)
e.add_node(f)
e.add_node(h)
f.add_node(g)
h.add_node(i)
i.add_node(j)
return a
def string_to_tree_node(string):
string = string.strip()
string = string[1:-1]
if not string:
return None
input_values = [s.strip() for s in string.split(',')]
root = TreeNode(int(input_values[0]))
node_queue = [root]
front = 0
index = 1
while index < len(input_values):
node = node_queue[front]
front = front + 1
item = input_values[index]
index = index + 1
if item != "null":
left_number = int(item)
node.left = TreeNode(left_number)
node_queue.append(node.left)
if index >= len(input_values):
break
item = input_values[index]
index = index + 1
if item != "null":
right_number = int(item)
node.right = TreeNode(right_number)
node_queue.append(node.right)
return root
def test_max_depth_1(self):
node4 = TreeNode(7, None, None)
node3 = TreeNode(15, None, None)
node2 = TreeNode(20, node3, node4)
node1 = TreeNode(9, None, None)
root = TreeNode(3, node1, node2)
test = self.leet104.max_depth(root)
self.assertEqual(test, 3)
def test_sorted_array_to_bst_1(self):
node5 = TreeNode(5, None, None)
node4 = TreeNode(-10, None, None)
node3 = TreeNode(9, node5, None)
node2 = TreeNode(-3, node4, None)
node1 = TreeNode(0, node2, node3)
test = self.leet108.sorted_array_to_bst([-10, -3, 0, 5, 9])
self.assertEqual(test.val, 0)
def test_is_balanced_1(self):
node5 = TreeNode(7, None, None)
node4 = TreeNode(15, None, None)
node3 = TreeNode(20, node4, node5)
node2 = TreeNode(9, None, None)
node1 = TreeNode(3, node2, node3)
test = self.leet110.is_balanced(node1)
self.assertEqual(test, True)
def test_min_depth_1(self):
node5 = TreeNode(7,None,None)
node4 = TreeNode(15,None,None)
node3 = TreeNode(20,node4,node5)
node2 = TreeNode(9,None,None)
node1 = TreeNode(3,node2,node3)
test = self.leet111.min_depth(node1)
self.assertEqual(test, 2)
def test_min_depth_1(self):
node5 = TreeNode(7, None, None)
node4 = TreeNode(15, None, None)
node3 = TreeNode(20, node4, node5)
node2 = TreeNode(9, None, None)
node1 = TreeNode(3, node2, node3)
test = self.leet112.has_path_sum(node1, 12)
self.assertEqual(test, True)
def test_is_symmetric_2(self):
node5 = TreeNode(3, None, None)
node4 = TreeNode(3, None, None)
node3 = TreeNode(2, None, node5)
node2 = TreeNode(2, None, node4)
node1 = TreeNode(1, node2, node3)
test = self.leet101.is_symmetric(node1)
self.assertEqual(test, False)
def test_node_init(self):
n = TreeNode(factor="amount",
level=3,
value=5,
w=-0.1434,
lo_branch="empty",
hi_branch="empty")
self.assertEqual("amount", n.factor)
n = TreeNode(**{'obj': 33.33})
self.assertEqual(33.33, n.obj)
def import_node(self, iter, key, tree):
type = get_json_type(tree)
if type == "Array":
new_iter = self.insert(iter, -1, row=[TreeNode(key, [])])
for child in tree:
self.import_node(new_iter, None, child)
elif type == "Object":
new_iter = self.insert(iter, -1, row=[TreeNode(key, {})])
for child_key, child in tree.items():
self.import_node(new_iter, child_key, child)
else:
self.insert(iter, -1, row=[TreeNode(key, tree)])
def _buildModel(self):
batches, specs = self._processDir()
self._root = TreeNode(None, None)
for batch in batches:
newNode = TreeNode(batch, self._root)
spec = specs.get(batch.name)
if spec:
for s in spec:
newNode.append_child(TreeNode(s, newNode))
self._root.append_child(newNode)
def loadfromInitData(self): rootNode = TreeNode(0,'root') tempid = 100 for key in data: parentNode = TreeNode(tempid,key,parent=rootNode) for leaf in data[key]: leafNode = TreeNode(leaf[0],leaf[1],color=leaf[2],accu=leaf[3],parent=parentNode) tempid += 1 self.mymodel = rootNode for node in self.mymodel.children: self.myscene.addItem(NodeGraphicsItem(node))
def _put(self, key, val, currentNode): if key <= currentNode.key: if currentNode.hasLeftChild(): self._put(key, val, currentNode.leftChild) else: currentNode.leftChild = TreeNode(key, val, parent=currentNode) self.updateBalance(currentNode.leftChild) else: if currentNode.hasRightChild(): self._put(key, val, currentNode.rightChild) else: currentNode.rightChild = TreeNode(key, val, parent=currentNode) self.updateBalance(currentNode.rightChild)
def make_tree(train_array):
global current_instances
global blocked_features
global tree_nodes
current_instances = []
while (calculate_global_entropy(current_instances) == 0):
current_instances.append(train_array.pop(0))
choose_root()
for ins in train_array:
(should_change, new_node_place, child_node,
parent_node) = tree_root.add_instance(ins)
current_instances.append(ins)
if (should_change):
#blocked_features = list(set().union(blocked_features , list(child_node.get_path_to_root().keys()) ))
#print(child_node.get_path_to_root())
#print(blocked_features)
related_instances = query(child_node.get_path_to_root())
new_feature_name = get_best_feature(parent_node, related_instances)
if (new_feature_name != None):
#blocked_features.append(new_feature_name) ####
(new_featre_total_labels,
new_feature_attr_labels) = get_feature_labels(
new_feature_name, related_instances)
new_node = TreeNode(parent_node, new_feature_name,
new_feature_attr_labels, None, True, True,
new_featre_total_labels)
parent_node.children_nodes[
new_node_place].visual_node.parent = None
parent_node.children_nodes[new_node_place] = new_node
try:
tree_nodes.remove(tree_nodes.index(child_node))
except:
pass
new_node_children_nodes = {}
new_node_children_labels = {}
tree_nodes.append(new_node)
for attr_name in list(new_node.children_labels.keys()):
temp_node = TreeNode(new_node, None, None, None, True,
False,
new_node.children_labels[attr_name])
new_node_children_nodes[str(attr_name)] = temp_node
tree_nodes.append(temp_node)
new_node.children_nodes = new_node_children_nodes
else:
continue
check_for_pull_up()
for pre, fill, node in RenderTree(tree_root.visual_node):
print("%s%s" % (pre, node.name))
def _put(self, root: TreeNode, key):
if root.key == key:
root.key = key
elif key < root.key:
if root.hasLeftChild():
self._put(root.leftChild, key)
else:
root.leftChild = TreeNode(key, root)
self._size += 1
else:
if root.hasRightChild():
self._put(root.rightChild, key)
else:
root.rightChild = TreeNode(key, root)
self._size += 1
def choose_root():
global current_labels
global current_instances
global tree_nodes
global visual_nodes
global tree_root
global blocked_features
tree_nodes = []
feature_dict = {}
for feature in list(current_instances[0].feature_dict.keys()):
if (feature not in blocked_features):
feature_dict[feature] = calculate_global_entropy(
current_instances) - get_feature_entropy(feature)
#print(feature_dict)
feature_name = max(feature_dict, key=feature_dict.get)
node = TreeNode(parent=None,
feature_name=str(feature_name),
children_labels=None,
children_nodes=None,
is_leaf=True,
is_feature=True,
labels=get_global_labels())
root = Node(node.feature_name)
blocked_features.append(node.feature_name)
visual_nodes.append(root)
tree_nodes.append(node)
tree_root = node
node_children_labels = {}
node_children_nodes = {}
for attr in get_feature_attrs(node.feature_name):
temp_node = TreeNode(parent=node,
feature_name=None,
children_labels=None,
children_nodes=None,
is_leaf=True,
is_feature=False,
labels=get_feature_attrs(node.feature_name)[attr])
temp_visual_node = Node(str(attr) + "[" + str(temp_node.labels[0]) +
"," + str(temp_node.labels[1]) + "]",
parent=root)
node_children_labels[str(attr)] = temp_node.labels
node_children_nodes[str(attr)] = temp_node
tree_nodes.append(temp_node)
node.children_labels = node_children_labels
node.children_nodes = node_children_nodes
current_instances = []
#print(node.feature_name)
return
def rebuild_tree(pre_order, in_order, length):
"""
根据前序遍历和中序遍历重建二叉树
所构建的二叉树是否唯一？参考：https://www.cnblogs.com/jiaxin359/p/9512348.html
:param pre_order:
:param in_order:
:param length:
:return:
"""
if len(pre_order) == 0 or len(in_order) == 0 or length <= 0:
return None
i = 0
tn = pre_order[0]
root = TreeNode(tn)
while i < length and in_order[i] != tn:
i += 1
if i == length:
return None
root.left = rebuild_tree(pre_order[1:], in_order, i)
root.right = rebuild_tree(pre_order[i + 1:], in_order[i + 1:],
length - i - 1)
return root
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
prev = TreeNode(-1) # fake node
res = []
if not root:
return res
stk = []
stk.append(root)
while stk:
top = stk[-1]
if top.left and top.left is not prev and top.right != prev:
cur = top.left
while cur:
stk.append(cur)
cur = cur.left
elif top.right and top.right is not prev:
cur = top.right
while cur:
stk.append(cur)
cur = cur.left
else:
prev = stk.pop()
res.append(prev.val)
return res
def addToTree(self, data):
"""Add data to the tree.
:param int data: data to be added to new node
"""
if self._findData(self.root, data):
raise Exception("Data already exists")
node = TreeNode(data)
tmp_node = self.root
parent_node = None
while tmp_node:
parent_node = tmp_node
if data < tmp_node.val:
tmp_node = tmp_node.left
else:
tmp_node = tmp_node.right
if not parent_node:
self.root = node
else:
if parent_node.val > data:
parent_node.setLeft(node)
else:
parent_node.setRight(node)
self.root = BinaryTree._balanceBst(self.root)
def sorted_array_to_bst(self, nums):
"""
Converted an array of nums into a tree.
Args:
nums -- An array of nums sorted in ascending order.
Returns:
TreeNode
"""
# Time: O(n) where n is the number of items in the list.
# Space: O(1)
if not nums:
return None
n = len(nums)
if n % 2 == 0:
mid = int(n / 2) - 1
else:
mid = int(n / 2)
node = TreeNode(nums[mid])
node.left = self.sorted_array_to_bst(nums[:mid])
node.right = self.sorted_array_to_bst(nums[mid + 1:])
return node
def read_tree(self, parent_line, token_line):
parents = list(map(lambda x: int(x) - 1,parent_line.split()))
tokens = token_line.strip().split()
tree_nodes = dict()
root = None
for i in range(len(parents)):
crnt_node_id = i
if crnt_node_id not in tree_nodes.keys():
prev_node = None
while True:
if crnt_node_id == -1:
break
parent_node_id = parents[crnt_node_id]
crnt_node = TreeNode()
if prev_node is not None:
crnt_node.add_child(prev_node)
tree_nodes[crnt_node_id] = crnt_node
crnt_node.idx = crnt_node_id
crnt_node.token = tokens[crnt_node_id]
#if trees[parent-1] is not None:
if parent_node_id in tree_nodes.keys():
tree_nodes[parent_node_id].add_child(crnt_node)
break
elif parent_node_id == -1:
root = crnt_node
break
else:
prev_node = crnt_node
crnt_node_id = parent_node_id
return root
def create(nums: list) -> TreeNode:
if not nums:
return
node = TreeNode(nums[len(nums) // 2])
node.left = create(nums[:len(nums) // 2])
node.right = create(nums[len(nums) // 2 + 1:])
return node
def _calc_split(self, data, target):
rv = {"obj": float("inf")}
for factor in [x for x in data.columns if x not in [target, Y]]:
values = data[factor].unique()
if len(values) > 1:
print("{} ({})".format(factor, len(values)))
for value in values:
print(".", end="", flush=True)
lo_data = data[data[factor] <= value]
hi_data = data[data[factor] > value]
if hi_data.shape[0] > 0:
obj, lo_w, hi_w = self._get_obj(
self._get_g(lo_data, target),
self._get_h(lo_data, target),
self._get_g(hi_data, target),
self._get_h(hi_data, target))
if obj < rv.get('obj'):
rv = {
'obj': obj,
'factor': factor,
'value': value,
'lo_data': lo_data,
'hi_data': hi_data,
'lo_w': lo_w,
'hi_w': hi_w
}
print("")
return TreeNode(
**{k: v
for k, v in rv.items() if k in TreeNode.fieldnames}), rv
def buildTree(self, preorder: list, inorder: list) -> TreeNode:
if preorder:
root = TreeNode(preorder[0])
mid = inorder.index(preorder[0])
root.left = self.buildTree(preorder[1:mid+1], inorder[0:mid])
root.right = self.buildTree(preorder[mid+1:len(preorder)], inorder[mid+1:len(inorder)])
return root
def test_node_evaluate(self):
n_low = TreeNode(w=-0.1434)
n_hi = TreeNode(w=-0.456)
n_week = TreeNode(factor="day_of_week",
value=3,
lo_branch=n_low,
hi_branch=n_hi)
n_bigamount = TreeNode(w=0.2)
n_root = TreeNode(factor="amount",
value=5,
lo_branch=n_week,
hi_branch=n_bigamount)
data1 = {'amount': 2, 'day_of_week': 2}
data2 = {'amount': 8, 'day_of_week': 2}
self.assertEqual(-0.1434, n_root.evaluate(data1))
self.assertEqual(0.2, n_root.evaluate(data2))
def test_9():
root9 = TreeNode(
20,
TreeNode(
10,
TreeNode(5, TreeNode(3, None, None), TreeNode(7, None, None)),
TreeNode(15, None, TreeNode(17, None, None))),
TreeNode(30, None, None))
return (BinarySearchTree.isBinarySearchTree(root9))
def __init__(self, root_val=None):
"""
Just need a pointer to root node
Args:
root_val (int): value to be stored in root node
"""
self.root = TreeNode(root_val)
def buildTree(self, inorder: list, postorder: list) -> TreeNode:
if inorder:
root = TreeNode(postorder[len(postorder) - 1])
mid = inorder.index(postorder[len(postorder) - 1])
root.left = self.buildTree(inorder[0:mid], postorder[0:mid])
root.right = self.buildTree(inorder[mid + 1:len(inorder)],
postorder[mid:len(inorder) - 1])
return root
