def testSearch(self):
tree = Tree()
for word in insert_queue:
tree.insert(word)
for i in insert_queue:
self.assertEqual(tree.search(i), i)
self.assertEqual(tree.search("not found"), None)
def test_new_tree_add_2_nodes_and_search_it(self):
t = Tree()
n = Node(title='test', id='1', parent_id='root')
t.add(n)
n = Node(title='test2', id='2', parent_id='1')
t.add(n)
#print(t)
result = t.search('2')
self.assertEqual(result.get_id(), '2')
class Eve:
def __init__(self, n, m, depth, save_permission):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.G = Game(n, m)
self.T1 = Tree(n, m, depth)
self.T2 = Tree(n, m, depth)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T1.EF.Hash = out
self.T2.EF.Hash = out
def start_game(self):
# first move: X
print('Start\n', self.G)
t = time.time()
for i in range(20):
if i % 2 == 0:
player = 1
next_move = self.T1.search(self.G.get_state())
else:
player = -1
next_move = self.T1.search(-self.G.get_state())
y, x = next_move
if self.G.input(y, x, player):
break
t = time.time() - t
print('Time:', t)
# save cache
self.S.save(self.T1.EF.Hash, self.T2.EF.Hash)
print('End')
def testDelete(self):
tree = Tree()
copy_q = copy(insert_queue)
for word in copy_q:
tree.insert(word)
tree.delete(copy_q[-1])
self.assertEqual(tree.search(copy_q[-1]), None)
copy_q.pop()
copy_q.sort()
self.assertEqual(tree.inorder_traverse(), " ".join(copy_q))
class Online:
def __init__(self, n, m, depth, save_permission, user_id, team_id,
game_id):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.SLEEP_TIME = 5
self.G = Game(n, m)
self.T = Tree(n, m, depth)
self.API = Api(user_id, team_id)
self.API.set_game_id(game_id)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T.EF.Hash = out
def start_game(self):
# first move: O
side = int(input('choose side\n0: O, 1: X'))
player = 1 if side == 1 else -1
print('Start\n', self.G)
while True:
while True:
players_turn = self.G.input_board_list(self.API.get_board())
if players_turn == player:
break
else:
print('Waiting for Player',
'X' if players_turn == 1 else 'O')
time.sleep(self.SLEEP_TIME)
print(self.G)
t = time.time()
y, x = self.T.search(self.G.get_state() * player)
print('Time:', time.time() - t)
self.API.make_move(y, x)
if self.G.input(y, x, player):
break
# save cache
self.S.save(self.T.EF.Hash)
print('End')
class Pve:
def __init__(self, n, m, depth, save_permission):
self.N = n
self.M = m
self.DEPTH = depth
self.SAVE_PERMISSION = save_permission
self.G = Game(n, m)
self.T = Tree(n, m, depth)
# load cache
self.S = Save(n, m, self.SAVE_PERMISSION)
out = self.S.load()
if out:
print('loaded')
self.T.EF.Hash = out
def start_game(self):
side = int(input('choose your side\n0: O, 1: X'))
player_1 = 1 if side == 0 else -1
# player_2 = -player_1
print('Start\n', self.G)
t = time.time()
player = 1
for i in range(100):
if player == player_1:
y, x = self.T.search(self.G.get_state() * player_1)
else:
y = int(input('y:'))
if y < 0:
break
x = int(input('x:'))
if self.G.input(y, x, player):
break
player = -player
t = time.time() - t
print('Time:', t)
# save cache
self.S.save(self.T.EF.Hash)
print('End')
def function_four():
t = Tree()
t.insert(35)
t.insert(13, t.root)
t.insert(11, t.root)
t.insert(15, t.root)
t.insert(19, t.root)
t.insert(99, t.root)
t.insert(9001, t.root)
t.insert(8263, t.root)
t.insert(35, t.root)
t.insert(9001, t.root)
print(t.search(99))
print("pre-ordered")
t.pre_order(t.root)
print("in order")
t.in_order(t.root)
def main():
start = time.time()
# read in the data as a list[list[tconst, average_rating, num_votes]]
data = parse_data()
data.sort(key=lambda record: (record[1], record[0]))
# init tree
tree = Tree()
# initialize data block
data_id = Disk.get_next_free()
data_block = Disk.read_block(data_id)
set_data_block_header(data_block, data_id)
# keep track of the number of data blocks
num_data_blocks = 0
# insert the data
for i, record in enumerate(data):
if i != 0 and i % 50000 == 0:
print(f"{i} records inserted")
record_bytes = convert_record_to_bytes(record)
# insert into data block
inserted_at = insert_record_bytes(data_block, record_bytes)
if inserted_at == -1:
num_data_blocks += 1
data_id = Disk.get_next_free()
data_block = Disk.read_block(data_id)
set_data_block_header(data_block, data_id)
inserted_at = insert_record_bytes(data_block, record_bytes)
assert inserted_at != -1
# write to disk for every record insertion
Disk.write_block(data_id, data_block)
# insert to B+ Tree (block_id, offset, key)
tree.insert((record[1], record[0]), (data_id, inserted_at))
end = time.time()
print(f"Seconds for insertion: {end-start}")
start = time.time()
tree.save()
end = time.time()
print(f"Seconds for saving tree to disk: {end-start}")
def get_ptr_key_sequence(node):
keys_list = node.keys
ptrs_list = node.get_child_ids()
lastPtr = ptrs_list.pop()
result = ""
result += "| headers | "
for ptrInd, ptrVal in enumerate(ptrs_list):
result += f"{ptrVal} | "
result += f"{keys_list[ptrInd]} | "
result += f"{lastPtr} | \n"
return result
def generate_select_query_statistic(leaf_nodes_dict, non_leaf_nodes_dict,
blocks_offsets_list, file_settings):
unique_data_block_ids = set(
block_id for block_id, _ in
blocks_offsets_list) # since pointers can point to same data block
selected_records = [
convert_bytes_to_record(
read_record_bytes(Disk.read_block(block_id), offset))
for block_id, offset in blocks_offsets
]
# Index Nodes
index_file = file_settings[0]
data_file = file_settings[1]
result_file = file_settings[2]
# index nodes
ind_file = open(index_file, "w")
ind_file.write("The content of the non-leaf index nodes:\n")
for ind, index_node in enumerate(Tracker.track_set["non-leaf"]):
if index_node.parent:
ind_file.write(
f"{ind}. node_id = {index_node.block_id} with parent_node_id = {index_node.parent.block_id}\n"
)
else:
ind_file.write(
f"Root Node's node_id = {index_node.block_id}\n")
ind_file.write(get_ptr_key_sequence(index_node))
ind_file.write("\nThe content of the leaf index nodes:\n")
count = 0
for index_node in Tracker.track_set[
"leaf"]: # might just give first 5 in report
count += 1
ind_file.write(
f"{count}. node_id = {index_node.block_id} with parent_block_id = {index_node.parent.block_id}\n"
)
ind_file.write(get_ptr_key_sequence(index_node))
print(
f"The number of index nodes the process accessed: {len(leaf_nodes_dict) + len(non_leaf_nodes_dict)} "
f"({len(non_leaf_nodes_dict)} Non-leaf nodes, {len(leaf_nodes_dict)} leaf nodes)"
)
print(f'Content of index nodes accessed saved to "{index_file}"\n')
# data blocks
d_file = open(data_file, "w")
d_file.write("The content of the data blocks:\n")
for data_block_id in unique_data_block_ids:
d_file.write(f"Records for data block with id {data_block_id}:\n")
d_file.write("| ")
d_file.write(
f"{' | '.join('{:^27}'.format(str(record)) for record in read_all_records_from_data_block(Disk.read_block(data_block_id)))}"
)
d_file.write(" |\n")
print(
f"The number of data blocks the process accessed: {len(unique_data_block_ids)}"
)
print(f'Content of data blocks accessed saved to "{data_file}"\n')
# tconst of movies
tconst_records = [record[0] for record in selected_records]
df = pd.DataFrame(tconst_records, columns=["tconst of movies"])
df.to_csv(result_file)
print(f"Result:")
print(
f'tconst of {len(selected_records)} movies saved to "{result_file}"\n'
)
# experiment 1
print("Experiment 1: Storing the data on the disk...\n")
block_count = num_data_blocks + 1
node_count = tree.get_num_nodes()
print(f"Total number of data blocks: {block_count}"
) # num_data_blocks were fully filled, last is partially filled
print(f"Total number of index nodes: {node_count}")
print(
f"Total size of database: ({block_count} + {node_count}) * {BLOCK_SIZE}B = {(block_count + node_count)*BLOCK_SIZE}B\n"
)
# experiment 2
print(
"Experiment 2: Building a B+ tree on the attribute 'averageRating'...\n"
)
print(f"The parameter n of the B+ tree is: {tree.root.max_keys}")
print(f"Total number of nodes in the B+ tree is: {tree.get_num_nodes()}")
print(f"The height of the B+ tree is: {tree.get_height()}")
print(f"The root node contents are: \n" f"node_id: {tree.root.block_id}")
print(get_ptr_key_sequence(tree.root))
print("The child node (of the root node) contents are:")
count = 0
for child in tree.root.pointers:
count += 1
print(f"{count}. node_id: {child.block_id}")
print(get_ptr_key_sequence(child))
# experiment 3
print(
"Experiment 3: Retrieving tconst of movies with averageRating == 8...\n"
)
file_settings = [
f"{BLOCK_SIZE}B_experiment_3_index_nodes.txt",
f"{BLOCK_SIZE}B_experiment_3_data_blocks.txt",
f"{BLOCK_SIZE}B_experiment_3_tconst_result.csv"
]
Tracker.reset_all()
blocks_offsets = tree.search(8.0)
generate_select_query_statistic(Tracker.track_set['leaf'],
Tracker.track_set['non-leaf'],
blocks_offsets, file_settings)
selected_records = [
convert_bytes_to_record(
read_record_bytes(Disk.read_block(block_id), offset))
for block_id, offset in blocks_offsets
]
# the part below only for validation
actual_records = []
for record in data:
if record[1] == 8.0:
actual_records.append(record)
assert sorted(selected_records) == sorted(actual_records)
# tree.validate()
# experiment 4
print(
"\nExperiment 4: Retrieving tconst of movies with 7 <= averageRating <= 9...\n"
)
file_settings = [
f"{BLOCK_SIZE}B_experiment_4_index_nodes.txt",
f"{BLOCK_SIZE}B_experiment_4_data_blocks.txt",
f"{BLOCK_SIZE}B_experiment_4_tconst_result.csv"
]
Tracker.reset_all()
blocks_offsets = tree.search_range(7.0, 9.0)
generate_select_query_statistic(Tracker.track_set['leaf'],
Tracker.track_set['non-leaf'],
blocks_offsets, file_settings)
selected_records = [
convert_bytes_to_record(
read_record_bytes(Disk.read_block(block_id), offset))
for block_id, offset in blocks_offsets
]
# the part below only for validation
actual_records = []
for record in data:
if 7.0 <= record[1] <= 9.0:
actual_records.append(record)
assert sorted(selected_records) == sorted(actual_records)
# tree.validate()
# experiment 5
Tracker.reset_all()
print(
"Experiment 5: Deleting movies with averageRating == 7 and Updating B+ Tree...\n"
)
tree.delete(7.0)
print(
f"The number of times that a node is deleted: {Tracker.track_counts['merge']}"
)
print(f"Total number of nodes in the B+ tree is: {tree.get_num_nodes()}")
print(f"The height of the B+ tree is: {tree.get_height()}")
print(f"The root node contents are: \n" f"node_id: {tree.root.block_id}")
print(get_ptr_key_sequence(tree.root))
print("The child node (of the root node) contents are:")
count = 0
for child in tree.root.pointers:
count += 1
print(f"{count}. node_id: {child.block_id}")
print(get_ptr_key_sequence(child))
# the part below only for validation
blocks_offsets = tree.search_range(None, None)
records_remaining = [
convert_bytes_to_record(
read_record_bytes(Disk.read_block(block_id), offset))
for block_id, offset in blocks_offsets
]
actual_records_remaining = [record for record in data if record[1] != 7.0]
assert sorted(records_remaining) == sorted(actual_records_remaining)
class TestTreeMethods(unittest.TestCase):
def setUp(self):
self.n1 = Node(title='node1', id='1', parent_id='root')
self.n2 = Node(title='node2', id='2', parent_id='1')
self.n3 = Node(title='node3', id='3', parent_id='1')
self.n4 = Node(title='node4', id='4', parent_id='2')
self.n5 = Node(title='node5', id='5', parent_id='4')
# set up tree with multiple nodes
self.t1 = Tree()
self.t1.add(self.n1) # node1 has many children
self.t1.add(self.n2)
self.t1.add(self.n3)
self.t1.add(self.n4)
self.t1.add(self.n5)
#print("Tree before the test:")
#print(self.t1)
# set up tree with only one node besides root
self.n6 = Node('node6', '6', parent_id='root')
self.one_node_tree = Tree()
self.one_node_tree.add(self.n6)
def tearDown(self):
self.n1 = None
self.n2 = None
self.n3 = None
self.n4 = None
self.n5 = None
self.n6 = None
self.t1 = None
self.t2 = None
def test_get_root(self):
self.assertEqual(self.t1.get_root().get_id(), 'root')
def test_init_node_not_have_id_root(self):
""" test init using a node who's id is not 'root'"""
n = Node(title='foo', id=0)
t = Tree(n)
self.assertEqual(t.get_root().get_id(), 'root')
def test_init_node_has_id_of_root(self):
n = Node(title='foo', id='root')
t = Tree(n)
self.assertEqual(t.get_root().get_id(), 'root')
def test_string_empty_tree(self):
t2 = Tree(None)
self.assertEqual(t2.__str__(), '|---Google_Drive\n')
def test_string_non_empty_tree(self):
print("You can't really test this...automatically")
print(self.t1)
def test_search_for_root(self):
result = self.t1.search('root')
self.assertTrue(result.get_id() == 'root')
def test_search_for_first_node_added(self):
result = self.t1.search('1')
self.assertTrue(result.get_id() == '1')
def test_search_for_nonexisting_node_in_one_node_tree(self):
result = self.one_node_tree.search(self.n2.get_id())
self.assertTrue(result == None)
def test_new_tree_add_2_nodes_and_print_it(self):
t = Tree()
n = Node(title='test', id='1', parent_id='root')
t.add(n)
n = Node(title='test2', id='2', parent_id='1')
t.add(n)
print(t)
def test_new_tree_add_2_nodes_and_search_it(self):
t = Tree()
n = Node(title='test', id='1', parent_id='root')
t.add(n)
n = Node(title='test2', id='2', parent_id='1')
t.add(n)
#print(t)
result = t.search('2')
self.assertEqual(result.get_id(), '2')
# From here down, tests are failing
def test_search_for_nested_leaf_node(self):
result = self.t1.search(self.n5.get_id())
self.assertTrue('5' == result.get_id())
def test_search_for_node1(self):
result = self.t1.search(self.n1.get_id())
self.assertTrue(result.get_id(), '1')
def test_search_for_node2(self):
result = self.t1.search(self.n2.get_id())
self.assertTrue(result.get_id(), '2')
def test_search_for_node3(self):
result = self.t1.search(self.n3.get_id())
self.assertTrue(result.get_id(), '3')
def test_search_for_node4(self):
result = self.t1.search(self.n4.get_id())
self.assertTrue(result.get_id(), '4')
def test_search_for_node5(self):
result = self.t1.search(self.n5.get_id())
self.assertTrue(result.get_id(), '5')
def test_search_empty_tree(self):
root = None
empty_tree = Tree(root)
result = empty_tree.search(self.n1.get_id())
self.assertEqual(result, None)
def test_check_that_node_was_added(self):
n = Node('test_node', id='7', parent_id='4')
was_added = self.t1.add(n)
#print(self.t1)
self.assertEqual(was_added, 1)
def test_add_node_whose_parent_is_in_tree(self):
""" test adding node whose parent is node4 """
n = Node('test_node2', id='8', parent_id='4')
was_added = self.t1.add(n) # should be 1
#print(self.t1)
self.assertEqual(was_added, 1)
def test_add_node_whose_parent_is_not_in_tree(self):
n = Node('test_node3', id='9', parent_id='0')
was_added = self.t1.add(n) # should be -1
self.assertEqual(was_added, -1)
def test_add_node_whose_parent_is_none(self):
n = Node('test_node', id='8')
was_added = self.t1.add(n) # should be 0
self.assertEqual(was_added, 0)
def test_search_empty_tree(self):
root = None
empty_tree = Tree(root)
result = empty_tree.search(self.n1.get_id())
self.assertEqual(result, None)
def branchAndPrice(data,
outputTreePickle=None,
printStatus=True,
gapLimit = 1e-9,
timeLimit = None, # Time limit in seconds
reducedTreeSize = True, # Reduce size of tree by deleting unnecessary data
resourceVec = ['TWMin', 'TWMin_g', 'TV'], # Resources used in the sub problem
removeIllegalColumns = False, # Remove all illegal columns before solving a problem
coverConstraint = '=', # Cover constraint. = or >=.
partialCG = False, # Only solve SPs until one with neg red cost is found
orderStrategy = 'random', # Strategy for choosing order of solving SP's
partialCG_constructionHeuristic = False, # Only solve SPs until one with neg red cost is found in construction heuristic
constructionHeuristic = 'CGartificialVariables', # Specify what construction heuristic to use
labelExtensionLimits = [], # Increments in SP label extension limit
SPSolutionsCount = 1, # Maximum number of SP solutions returned from one SPPRC iteration
sizeLimit = None, # Limit size of tree
CGOptimalityGapLimit=1e-9, # CG stop criterion optimality gap
CGImprovementStepSize=1, # CG improvement criterion step size
CGImprovementThreshold=1e-9, # CG improvement criterion threshold
branchOnUpperBound=False, # Branch once CG finds objective value below tree upper bound
branchingStrategy = 'xVars'
):
'''Branch-and-Price algorithm for solving the roster problem. If a tree
pickle filename is given, branch-and-price continues on the given tree.
'''
'''Initializations'''
# Start time
refTime = time.time()
# Start time for initializations
start = time.time()
# Set margin for numerical error
epsilon = 1e-9
terminate = False
# Retrieve inputs to branch and price function
# Array to store configuration
configuration = {}
# Retrieve function arguments
frame = inspect.currentframe()
arguments, _, _, values = inspect.getargvalues(frame)
# Save all arguments relevant
for argument in arguments:
if argument not in ['data', 'outputTreePickle']:
configuration[argument] = values[argument]
# Problem k to be solved
k = 0
# Initialize branch-and-bound tree
tree = Tree(configuration, refTime)
# Initialize columns and graphs
graphs = dict.fromkeys(employee for employee in data['Employees'])
for employee in data['Employees']:
graphs[employee] = Graph(data=data, employee=employee)
stop = time.time()
tree.times['Branch and price']['Initializations'] += stop - start
start = time.time()
# Generate initial columns
columns = Columns(data=data, graphs = graphs,
constructionHeuristic = constructionHeuristic,
printStatus = printStatus,
orderStrategy = orderStrategy,
partialCG_constructionHeuristic = partialCG_constructionHeuristic,
coverConstraint = coverConstraint,
removeIllegalColumns = removeIllegalColumns,
resourceVec = resourceVec)
stop = time.time()
tree.times['Branch and price']['Construction heuristic'] += stop - start
start = time.time()
# Define root problem
rootProblem = Problem(ID=k, columns=columns, graphs=graphs, data=data,
coverConstraint=coverConstraint)
# Add root problem to tree
tree.addProblem(problem=rootProblem)
stop = time.time()
tree.times['Branch and price']['Initializations'] += stop - start
tree.times['Total'] += time.time() - tree.times['refTime']
tree.times['refTime'] = time.time()
'''Main Loop'''
while not terminate:
# Select problem k from unprocessedProblems
Pk = tree.unprocessedProblems[k]
# If required and not root problem, remove illegal columns from Pk
if k > 0 and removeIllegalColumns:
# Remove from columns object
removedColumnNumbers = Pk.columns.removeIllegalColumns(data = data)
# Delete all removed columns from master problem object
Pk.masterProblem.delVariable(['lambda({},{})'.format(e, k) for e in removedColumnNumbers for k in removedColumnNumbers[e]])
# Prepare timing for solving problem k
tree.times['Total'] += time.time() - tree.times['refTime']
tree.times['refTime'] = time.time()
# Check if time limit is reached while not already terminated
if timeLimit != None and tree.times['Total'] > timeLimit:
if printStatus:
print('Time limit {:.0f} s reached. Process terminated.'.format(timeLimit))
savePickle(tree, outputTreePickle)
# Terminate function
return
# Solve problem k
Pk.solve(data = data, epsilon = epsilon, partialCG = partialCG,
orderStrategy = orderStrategy,
partialCG_constructionHeuristic = partialCG_constructionHeuristic,
labelExtensionLimits=labelExtensionLimits,
SPSolutionsCount=SPSolutionsCount,
removeIllegalColumns = removeIllegalColumns,
CGOptimalityGapLimit=CGOptimalityGapLimit,
CGImprovementStepSize=CGImprovementStepSize,
CGImprovementThreshold=CGImprovementThreshold,
branchOnUpperBound=branchOnUpperBound,
treeUpperBound=tree.upperBoundProblem.upperBound,
times = tree.times,
resourceVec = resourceVec,
timeLimit=timeLimit)
stop = time.time()
tree.times['Total'] += time.time() - tree.times['refTime']
tree.times['refTime'] = time.time()
# Check if time limit is reached while not already terminated
if timeLimit != None and tree.times['Total'] > timeLimit:
if Pk.processed:
# Remove master problem and reduce size
Pk.masterProblem = None
Pk.reduceSize(data = data)
# Move problem k from unprocessedProblems to processedProblems
tree.processedProblems[k] = tree.unprocessedProblems.pop(k)
if printStatus:
print('Time limit {:.0f} s reached. Process terminated.'.format(timeLimit))
savePickle(tree, outputTreePickle)
# Terminate function
return
# Move problem k from unprocessedProblems to processedProblems
tree.processedProblems[k] = tree.unprocessedProblems.pop(k)
# If Pk infeasible, or without potential of improvement
if not Pk.feasible or Pk.lowerBound > tree.upperBoundProblem.upperBound:
# Prune node
Pk.pruned = True
# Delete master problem in node
Pk.masterProblem = None
# Else if the final solution is integer
elif Pk.integer:
# Update upper bound if better solution found
if Pk.upperBound < tree.upperBoundProblem.upperBound:
tree.upperBoundProblem = Pk
# Prune all unprocessed problem with lower bound above new upper bound
tree.pruneOnUpperBound()
# Prune node (integer)
Pk.pruned = True
# Delete master problem in node
Pk.masterProblem = None
# Otherwise, update upper bound if Pk had a better integer solution than
# the current upper bound problem and branch problem
else:
if Pk.upperBound and Pk.upperBound < tree.upperBoundProblem.upperBound:
tree.upperBoundProblem = Pk
# Prune all unprocessed problem with lower bound above new upper bound
tree.pruneOnUpperBound()
start = time.time()
# Branch the problem
tree.branch(problem = Pk, branchingStrategy = branchingStrategy, data = data)
stop = time.time()
tree.times['Branch and price']['Branch'] += stop - start
tree.times['Total'] += time.time() - tree.times['refTime']
tree.times['refTime'] = time.time()
# Reduce size of problem by removing unnecessary attributes
Pk.reduceSize(data)
# Update lower bound and optimality gap
tree.calculateLowerBound()
tree.calculateOptimalityGap()
tree.times['Total'] += time.time() - tree.times['refTime']
tree.times['refTime'] = time.time()
# Check termination criterion
if tree.terminationCriterion(sizeLimit=sizeLimit, gapLimit = gapLimit):
terminate = True
tree.complete = True
savePickle(tree, outputTreePickle)
# Terminate function
return
# Else: update k according to search strategy
else:
# If no integer solution found (no UBD): use depth first search
if tree.upperBoundProblem.upperBound == float('inf'):
searchStrategy = 'DepthFirst_Up'
# Else: use best first search
else:
searchStrategy = 'BestFirst'
# Search and store time
start = time.time()
k = tree.search(searchStrategy)
stop = time.time()
tree.times['Branch and price']['Search'] += stop - start
tree.times['Total'] += time.time() - tree.times['refTime']
tree.times['refTime'] = time.time()
if printStatus:
nProcessedProblems = len(tree.processedProblems)
if tree.upperBoundProblem == Pk:
print('New upper bound found')
if tree.upperBoundProblem == Pk or (nProcessedProblems<=10 or
(nProcessedProblems<=50 and nProcessedProblems%2 == 0) or
nProcessedProblems%10 == 0):
printMessage(nProcessedProblems, tree.upperBoundProblem.upperBound,
tree.lowerBound, tree.gap, tree.times['Total'])
# print(tree.search(8))
while True:
action = input(
'Type sort or search to sort the tree or search for a number or exit to close the program\n'
)
if action == 'sort':
tree.traverse()
elif action == 'search':
while True:
try:
num = int(
input(
'What number would you like to search the tree for...\n'
))
except ValueError:
print(
'Hmm... something doesnt seem quite right please only search for positive integers'
)
continue
else:
print(tree.search(num))
break
elif action == 'exit':
break
else:
print(
'Hmm... something doesnt seem quite right make sure you typed one of the options'
)
# Caso 1: Inserção
texto = "testando texto teste testa teste tex t"
lista_texto = texto.split()
print("vvv Teste de Inserção vvv")
for idx, palavra in enumerate(lista_texto):
print("'" + palavra + "' inserido.")
t.insert(palavra, idx)
print("^^^ Teste de Inserção ^^^")
t.print_tree()
print("size: " + str(t.size))
print("^^^ Resultado (Inserção) ^^^")
# Caso 2: Busca
print("vvv Teste de Busca vvv")
for idx, palavra in enumerate(lista_texto):
r = t.search(palavra)
print("busca por: '" + palavra + "'. Resultado: " + str(r) + " Esperado: " + str(idx))
print("^^^ Teste de Busca ^^^")
# Caso 3: Remoção
print("vvv Teste de Remoção - Meio vvv")
print("removendo 't'")
t.remove("t")
print("removendo 'testa'")
t.remove("testa")
print("^^^ Teste de Remoção - Meio ^^^")
t.print_tree()
print("size: " + str(t.size))
print("^^^ Resultado (Remoção - Meio) ^^^")
from tree import Tree tree = Tree() tree.add_value(4) tree.add_value(3) tree.add_value(7) tree.add_value(5) # tree.traverse() tree.search(7) tree.search(6) tree.search(2)
from tree import Tree
from random import randint
tree = Tree()
for i in range(0, 10):
tree.add_value(randint(0, 100))
tree.traverse()
search = int(input('What value do you want to find?'))
result = tree.search(search)
if result is not None:
print('Found:', result)
else:
print(search, ' not found :(')
