def test_get_levels():
for invalid_argument in [None, 1, 'foo']:
with pytest.raises(ValueError) as err:
get_levels(invalid_argument)
assert str(err.value) == 'Expecting a list or a node'
assert str(get_levels(convert([0, 1,
2]))) == '[[Node(0)], [Node(1), Node(2)]]'
assert str(get_levels(convert([0, 1, 2]),
show_values=True)) == '[[0], [1, 2]]'
assert str(get_levels(convert([0, 1]), show_values=True, show_nulls=True))\
== '[[0], [1, None]]'
def test_get_level():
for invalid_argument in [None, 1, 'foo']:
with pytest.raises(ValueError) as err:
get_level(invalid_argument, 0)
assert str(err.value) == 'Expecting a list or a node'
for invalid_argument in [None, -1, 'foo']:
with pytest.raises(ValueError) as err:
get_level(convert([0, 1, 2]), invalid_argument)
assert str(
err.value) == 'Requested level must be a non-negative integer.'
with pytest.raises(ValueError) as err:
get_level(convert([0, 1, 2]), 2)
assert str(err.value) == 'Requested level not present in tree.'
assert str(get_level(convert([0, 1, 2]), 1)) == '[Node(1), Node(2)]'
assert str(get_level(convert([0, 1, 2]), 1, show_values=True)) == '[1, 2]'
assert str(get_level(convert([0, 1, 2, 3]), 2, show_values=True, show_nulls=True))\
== '[3, None, None, None]'
def make_tree(D):
r = range(0, len(D))
pairs = [(i, j) for i in r for j in r if i < j]
nodes = []
while len(pairs) != 0:
# look for the pair with the smallest distance
for (i, j) in pairs:
if D[i][j] == min([D[h][k] for (h,k) in pairs]):
j_node = None
i_node = None
# check if the pair members are already in nodes
for n in nodes:
# traverse node and see if it connects to either i or j
# choose the largest node (placed in front of the nodes list)
# and do not overwrite a newer large node with an older smaller one
# the tree is converted to a list for easy search
values = bt.convert(n)
if i in values:
i_node = n
if j in values:
j_node = n
# if not, assign them to nodes
if not j_node:
j_node = bt.Node(j)
if not i_node:
i_node = bt.Node(i)
# finally, join the created or found nodes by the root
# NOTE: make node values -1 to avoid distance and coordinate conflict
# this could be solved by mapping the (i,j) coordinates to alphabetic names
root = bt.Node("D({},{})={}".format(i, j, str(D[i][j])))
root.left = j_node
root.right = i_node
# place the node in front of the list
# this naturally ensures that complete nodes are in front and incomplete nodes in the tail
nodes.insert(0, root)
pairs.remove((i, j))
return nodes[0]
def fromNodetoTreeNode(root):
if not root:
return None
vals = convert(root)
tNodes = [None for _ in vals]
tRoot = TreeNode(vals[0])
tNodes[0] = tRoot
index = 1
while index < len(tNodes):
val = vals[index]
parenttNode = tNodes[int((index + 1) / 2) - 1]
if val:
newtNode = TreeNode(val)
tNodes[index] = newtNode
if (index % 2):
parenttNode.left = newtNode
else:
parenttNode.right = newtNode
index += 1
return tRoot
def convert_inspect(target):
return inspect(convert(target))
def test_convert():
for invalid_argument in [1, 'foo', int]:
with pytest.raises(ValueError) as err:
convert(invalid_argument)
assert str(err.value) == 'Expecting a list or a node'
assert convert(None) == []
# Convert trees to lists
for convert_func in [convert, lambda node: node.to_list()]:
root = Node(1)
assert convert_func(root) == [1]
root.right = Node(3)
assert convert_func(root) == [1, None, 3]
root.left = Node(2)
assert convert_func(root) == [1, 2, 3]
root.left.right = Node(4)
assert convert_func(root) == [1, 2, 3, None, 4]
root.right.left = Node(5)
assert convert_func(root) == [1, 2, 3, None, 4, 5]
root.right.right = Node(6)
assert convert_func(root) == [1, 2, 3, None, 4, 5, 6]
root.right.right = Node(None)
with pytest.raises(ValueError) as err:
assert convert_func(root)
assert str(err.value) == 'A node cannot have a null value'
root.right.right = {}
with pytest.raises(ValueError) as err:
assert convert_func(root)
assert str(err.value) == 'Found an invalid node in the tree'
# Convert lists to trees
with pytest.raises(ValueError) as err:
convert([None, 2, 3])
assert str(err.value) == 'Node missing at index 0'
with pytest.raises(ValueError) as err:
convert([1, 2, None, 3, 4, 5, 6])
assert str(err.value) == 'Node missing at index 2'
assert convert([]) is None
bt = convert([1])
assert attr(bt, 'value') == 1
assert attr(bt, 'left') is None
assert attr(bt, 'right') is None
bt = convert([1, 2])
assert attr(bt, 'value') == 1
assert attr(bt, 'left.value') == 2
assert attr(bt, 'right') is None
assert attr(bt, 'left.left') is None
assert attr(bt, 'left.right') is None
bt = convert([1, None, 3])
assert attr(bt, 'value') == 1
assert attr(bt, 'left') is None
assert attr(bt, 'right.value') == 3
assert attr(bt, 'right.left') is None
assert attr(bt, 'right.right') is None
bt = convert([1, 2, 3])
assert attr(bt, 'value') == 1
assert attr(bt, 'left.value') == 2
assert attr(bt, 'right.value') == 3
assert attr(bt, 'left.left') is None
assert attr(bt, 'left.right') is None
assert attr(bt, 'right.left') is None
assert attr(bt, 'right.right') is None
def convert_self_show_all(target):
convert(target).show_all()
def convert_show_all(target):
show_all(convert(target))
def convert_self_show_ids(target):
convert(target).show_ids()
def convert_self_show(target):
convert(target).show()
def convert_show(target):
show(convert(target))
def add(self, t, var, value, dtype, index=0):
def solve_lower(var, value):
from .model import Model
lower_value = math.floor(value)
m_lower = Model(dtype=dtype)
m_lower.create_from_tableau(ex_tv=relaxedTV_lower)
try:
m_lower.add_lazy_constraint(var['x'] <= lower_value)
return True, m_lower
except InfeasibleError:
return False, m_lower
def solve_upper(var, value):
from .model import Model
upper_value = math.ceil(value)
m_upper = Model(dtype=dtype)
m_upper.create_from_tableau(ex_tv=relaxedTV_upper)
try:
m_upper.add_lazy_constraint(var['x'] >= upper_value)
return True, m_upper
except InfeasibleError:
return False, m_upper
def to_string(s):
if isinstance(s, float):
if np.isinf(s):
return ''
else:
return str(s)
else:
return str(s)
print("Branch and bound index", index)
relaxedTV_lower = t.deepcopy()
relaxedTV_upper = t.deepcopy()
self.remove_from_tree(index)
lower_feasible, lower_model = solve_lower(var, value)
upper_feasible, upper_model = solve_upper(var, value)
print("Solved lower and upper")
self.add_left(index, lower_model)
self.add_right(index, upper_model)
obj_list = [to_string(x) for x in self.tree_obj]
tree = convert(obj_list)
pprint(tree)
best_unexplored_model, best_index = self.get_best_unexplored()
print("Best index", best_index)
if best_unexplored_model:
solved = best_unexplored_model.solve_mip(self, best_index)
if solved:
obj = best_unexplored_model.get_solution_object()[-1]
if self.check_if_better(obj, best_unexplored_model):
print("Found best", obj)
__author__ = 'harshul' from interactivepython.basic.tree import Node #using python package for binary tree: https://pypi.python.org/pypi/binarytree from binarytree import tree, pprint, inspect, convert, heapify mytree = tree(height=2, balanced=True) #pprint(mytree) my_list = [5, 4, 6, 3, 1, 2, 7, 8] # Convert the list into a tree and return its root my_tree = convert(my_list) pprint(my_tree) # Convert the list into a heap and return its root heapify(my_list) my_tree = convert(my_list) pprint(my_tree) # Convert the tree back to a list my_list = convert(my_tree) # Pretty-printing also works on lists pprint(my_list)
from binarytree import tree, bst, pprint, inspect, convert
my_bst = convert([8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15])
pprint(my_bst)
class Node:
def __init__(self, value):
self.right = None
self.left = None
self.value = value
self.parent = None
def find_max(node):
if node is None:
return
while node.right:
node = node.right
return node
def find_min(node):
if node is None:
return
while node.left:
node = node.left
return node
def set_parents(node):
if node is None:
def convert_pprint(target):
pprint(convert(target))
def convert_show_ids(target):
show_ids(convert(target))
cur = cur.right
if not cur:
flag = 0
cur = self.root
if not cur:
print("could not generate the random number")
return 0
def get_randomnode_1(self):
index = random.randint(0, self.root.size)
while True:
val = get_i_node(self.root, index)
if val != None:
return val
if __name__ == "__main__":
n = int(input("what is height of tree?"))
head = bst(n)
lt = convert(head)
bshead = bs_tree()
for i in range(len(lt)):
if lt[i]:
bshead.insert(knode(lt[i]))
print("Input Binary tree is ")
pprint(bshead.root)
while True:
input("enter key to genearte a random number")
print("The random value = %d" % bshead.get_randomnode())
while prev and prev.left != cur:
cur = prev
prev = prev.parent
return prev
else:
return cur
def display(self, msg):
print(msg)
pprint(self.root)
if __name__ == "__main__":
n = int(input("what is height of tree?"))
my_bst = bst(n)
lst = convert(my_bst)
bt = BinarySearchTree()
for i in range(len(lst)):
if lst[i] != None:
bt.insert(knode(lst[i]))
bt.display("The input tree is ")
print("The inoder traversal is as follows")
inorder(bt.root)
print()
while 1:
val = int(input("Enter the value to find the inorder sucessor"))
cur = bt.find(val)
if cur:
nxt = bt.find_sucessor(cur)
if nxt:
print("The inorder successor of %d is %d" %
