def test_key02(self): key_list = [ (90, '이상해씨'), (50, '이상해풀'), (150, '이상해꽃'), (20, '파이리'), (75, '리자드'), (95, '리자몽'), (175, '꼬부기'), (5, '어니부기'), (25, '거북왕'), (66, '캐터피'), (80, '단데기'), (92, '버터플'), (111, '뿔충이'), (166, '딱충이'), (200, '독침붕') ] bst = BinarySearchTree() for key, value in key_list: bst.insert_node(key, value) self.assertTrue(is_bst(bst.get_root())) for key, value in key_list: temp_bst = copy.deepcopy(bst) temp_bst.delete_node(key) self.assertTrue(is_bst(bst.get_root()))
def main(): target_list = [ (8, '여덟'), (2, '둘'), (9, '아홉'), (3, '셋'), (6, '여섯'), (5, '다섯'), (4, '넷'), (1, '하나'), (7, '일곱') ] print(target_list) bst = BinarySearchTree() for key, value in target_list: bst.insert_node(key, value) bst.print_bst() for key, value in target_list: copied_bst = copy.deepcopy(bst) print('Delete {0}'.format(key)) copied_bst.delete_node(key) copied_bst.print_bst() print('Is Binary Search Tree? {0}'.format(is_bst(copied_bst.get_root())))
def test_key01(self): key_list = [8, 3, 10, 1, 6, 4, 7, 14, 13] bst = BinarySearchTree() for key in key_list: bst.insert_node(key, None) self.assertTrue(is_bst(bst.get_root())) for key in key_list: temp_bst = copy.deepcopy(bst) temp_bst.delete_node(key) self.assertTrue(is_bst(bst.get_root()))
def test_key04(self): key_list = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] bst = BinarySearchTree() for key in key_list: bst.insert_node(key, None) self.assertTrue(is_bst(bst.get_root())) for key in key_list: temp_bst = copy.deepcopy(bst) temp_bst.delete_node(key) self.assertTrue(is_bst(bst.get_root()))
def test_max(self): """ test the following binary search tree 1 \ 2 \ 3 """ bst = BinarySearchTree() bst.insert(1) bst.insert(2) expected_max = bst.insert(3) self.assertEqual(bst.max(), expected_max)
def test_insert(self): """ test the following binary search tree 4 / \ / \ 2 6 / \ / \ 1 3 5 7 """ bst = BinarySearchTree() root = bst.insert(4) self.assertEqual(bst.root, root) left_child = bst.insert(2) self.assertEqual(bst.root.left_child, left_child) left_child_left_child = bst.insert(1) self.assertEqual(bst.root.left_child.left_child, left_child_left_child) left_child_right_child =bst.insert(3) self.assertEqual(bst.root.left_child.right_child, left_child_right_child) right_child = bst.insert(6) self.assertEqual(bst.root.right_child, right_child) right_child_left_child = bst.insert(5) self.assertEqual(bst.root.right_child.left_child, right_child_left_child) right_child_right_child = bst.insert(7) self.assertEqual(bst.root.right_child.right_child, right_child_right_child)
def test_min(self): """ test the following binary search tree 3 / 2 / 1 """ bst = BinarySearchTree() bst.insert(3) bst.insert(2) expected_min = bst.insert(1) self.assertEqual(bst.min(), expected_min)
def test_prev_node_of_min(self): """ test the following binary search tree 1 \ 2 \ 3 <-- get next node of 3 """ bst = BinarySearchTree() bst.insert(1) bst.insert(2) node = bst.insert(3) self.assertEqual(bst.next(node), None)
def test_prev_node_of_min(self): """ test the following binary search tree 3 / 2 / 1 <-- get prev node of 1 """ bst = BinarySearchTree() bst.insert(3) bst.insert(2) node = bst.insert(1) self.assertEqual(bst.prev(node), None)
def test_next_node_has_right_subtree(self): """ test the following binary search tree 1 <-- get next node of 1 \ 3 / \ 2 4 """ bst = BinarySearchTree() node = bst.insert(1) bst.insert(3) expected_next = bst.insert(2) bst.insert(4) self.assertEqual(bst.next(node), expected_next)
def test_prev_node_has_no_left_subtree(self): """ test the following binary search tree 4 / 1 \ 3 / 2 <-- get prev node of 2 """ bst = BinarySearchTree() bst.insert(4) expected_prev = bst.insert(1) bst.insert(3) node = bst.insert(2) self.assertEqual(bst.prev(node), expected_prev)
class MemoryCache(object): def __init__(self, size=100, capacity=120): self.size = size self.capacity = capacity self.current_size = 0 self.stats_init() self.tree = BinarySearchTree() def stats_init(self): self.hit = 0 self.miss = 0 def set(self, key, value): self.tree.insert_node(key, value) self.current_size += 1 if self.current_size > self.capacity: self.shrink() def get(self, key): val = self.tree.find(key) if val: self.hit += 1 else: self.miss += 1 return None return val def stats(self): return "\nhit: %s\nmiss: %s\nhit_ratio: %s\n" %(self.hit, self.miss, \ float(self.hit) / (self.miss+self.hit)) def shrink(self): for i in range(1,self.current_size - self.size): result = self.tree.shrink() while not result: result = self.tree.shrink()
def factor1(target): start_time = time() num_states = 1 if not isinstance(target, IntegerBase2): target = IntegerBase2(target) key_func = partial(lambda x, target: target.as_int - x.as_int, target=target) frontier = BinarySearchTree(key_func) num_digits = target_to_max_factor_num_digits(target, 0) for i, j in itertools.combinations_with_replacement(xrange(BASE), 2): p_digits = [0 for _ in xrange(num_digits)] q_digits = [0 for _ in xrange(num_digits)] p_digits[-1] = i q_digits[-1] = j _prod = Product(p_digits, q_digits) frontier.insert(_prod) solved = False while len(frontier): candidate = frontier.pop_min() #print #print IntegerBase2.from_int(target) #print candidate #from time import sleep #sleep(1) children = candidate.generate_children() for child in children: if child.as_int > target.as_int: continue elif child.as_int == target.as_int: print 'Solution!', child solved = True break else: frontier.insert(child) num_states += 1 if solved: break end_time = time() print 'States checked:', num_states print 'Time taken: {:.2f}s'.format(end_time - start_time)
def factor1(target): start_time = time() num_states = 1 if not isinstance(target, IntegerBaseFixed): target = IntegerBaseFixed(target) key_func = partial(product_to_error, target=target) frontier = BinarySearchTree(key_func) for i, j in itertools.combinations_with_replacement(xrange(BASE), 2): frontier.insert(ProductFixed(i, j)) solved = False while len(frontier): candidate = frontier.pop_min() #print #print IntegerBaseFixed.from_int(target) #print candidate #from time import sleep #sleep(1) if candidate.as_int() == target: print 'Solution!', candidate break children = candidate.generate_children() children = filter_digit_length(children, target) children = filter_correct_digits(children, target) for child in children: frontier.insert(child) num_states += len(children) if not num_states % 10000: print 'Checked:', num_states end_time = time() print 'States checked:', num_states print 'Time taken: {:.2f}s'.format(end_time - start_time)
def test_traverse_in_order(self): """ test the following binary search tree 4 / \ / \ 2 6 / \ / \ 1 3 5 7 """ bst = BinarySearchTree() node_4 = bst.insert(4) node_2 = bst.insert(2) node_1 = bst.insert(1) node_3 = bst.insert(3) node_6 = bst.insert(6) node_5 = bst.insert(5) node_7 = bst.insert(7) ordered_tree = bst.traverse_in_order() expected = [node_1, node_2, node_3, node_4, node_5, node_6, node_7] self.assertTrue(all(a == b for a, b in zip(ordered_tree, expected)))
#encoding=utf8 from binary_search_tree import BinarySearchTree if __name__ == '__main__': bst = BinarySearchTree() bst.insert_node(3,3) bst.insert_node(1,1) bst.insert_node(5,5) bst.insert_node(4,4) bst.insert_node(2,2) bst.print_tree()
class BinarySearchTreeTests(unittest.TestCase): def setUp(self): self.bst = BinarySearchTree(5) def test_depth_first_for_each_executes_callback(self): arr = [] def cb(x): arr.append(x) self.bst.insert(2) self.bst.insert(3) self.bst.insert(7) self.bst.insert(9) self.bst.depth_first_for_each(cb) self.assertEqual(arr, [5, 2, 3, 7, 9]) def test_breadth_first_for_each_executes_callback(self): arr = [] def cb(x): arr.append(x) self.bst.insert(3) self.bst.insert(4) self.bst.insert(10) self.bst.insert(9) self.bst.insert(11) self.bst.breadth_first_for_each(cb) self.assertEqual(arr, [5, 3, 10, 4, 9, 11])
from binary_search_tree import BinarySearchTree # Set up tree tree = BinarySearchTree(4) # Insert tree elements tree.insert(2) tree.insert(1) tree.insert(3) tree.insert(5) # Test search print(tree.search(4)) print(tree.search(6))
f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() # duplicates = [] # for name_1 in names_1: # for name_2 in names_2: # if name_1 == name_2: # duplicates.append(name_1) # using BST to improve speed duplicates = [] bst = BinarySearchTree("names") for name_1 in names_1: bst.insert(name_1) for name_2 in names_2: if bst.contains(name_2): duplicates.append(name_2) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds") # ---------- Stretch Goal ----------- # Python has built-in tools that allow for a very efficient approach to this problem # What's the best time you can accomplish with no restrictions on techniques or data # structures?
bt.add(6) bt.add(9) bt.add(15) bt.add(12) bt.add(11) bt.add(14) bt.add(17) bt.add(16) bt.add(19) # small tree if False: bt = BinarySearchTree() bt.add('a') bt.add('d') bt.add('e') bt.add('f') bt.add('b') bt.add('c') bt.show_all() bt.show_all_visual() for e in ['a', 'e', 'j']: check_for(bt, e) print
def test_insert(self): tree = BinarySearchTree() array = [5, 1, 7, 4, 3, 6, 9, 10, 19, 15] for item in array: tree.insert(item) self.assertEqual(tree.root.right.left.data, 6)
f = open('names_1.txt', 'r') names_1 = f.read().split("\n") # List containing 10000 names f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() duplicates = [] """for name_1 in names_1: for name_2 in names_2: if name_1 == name_2: duplicates.append(name_1)""" search = BinarySearchTree('names') for names in names_1: search.insert(names) for name in names_2: if search.contains(name): duplicates.append(name) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds") # ---------- Stretch Goal ----------- # Python has built-in tools that allow for a very efficient approach to this problem # What's the best time you can accomplish with no restrictions on techniques or data # structures?
def setUp(self): self.bst = BinarySearchTree(5)
class BinarySearchTreeTests(unittest.TestCase): def setUp(self): self.bst = BinarySearchTree(5) def test_insert(self): self.bst.insert(2) self.bst.insert(3) self.bst.insert(7) self.bst.insert(6) self.assertEqual(self.bst.left.right.value, 3) self.assertEqual(self.bst.right.left.value, 6) def test_handle_dupe_insert(self): self.bst2 = BinarySearchTree(1) self.bst2.insert(1) self.assertEqual(self.bst2.right.value, 1) def test_contains(self): self.bst.insert(2) self.bst.insert(3) self.bst.insert(7) self.assertTrue(self.bst.contains(7)) self.assertFalse(self.bst.contains(8)) def test_get_max(self): self.assertEqual(self.bst.get_max(), 5) self.bst.insert(30) self.assertEqual(self.bst.get_max(), 30) self.bst.insert(300) self.bst.insert(3) self.assertEqual(self.bst.get_max(), 300) def test_for_each(self): arr = [] def cb(x): return arr.append(x) v1 = random.randint(1, 101) v2 = random.randint(1, 101) v3 = random.randint(1, 101) v4 = random.randint(1, 101) v5 = random.randint(1, 101) self.bst.insert(v1) self.bst.insert(v2) self.bst.insert(v3) self.bst.insert(v4) self.bst.insert(v5) self.bst.for_each(cb) self.assertTrue(5 in arr) self.assertTrue(v1 in arr) self.assertTrue(v2 in arr) self.assertTrue(v3 in arr) self.assertTrue(v4 in arr) self.assertTrue(v5 in arr) def test_print_traversals(self): # WARNING: Tests are for Print() # Debug calls to Print() in functions will cause failure stdout_ = sys.stdout # Keep previous value sys.stdout = io.StringIO() self.bst = BinarySearchTree(1) self.bst.insert(8) self.bst.insert(5) self.bst.insert(7) self.bst.insert(6) self.bst.insert(3) self.bst.insert(4) self.bst.insert(2) # self.bst.in_order_print(self.bst) # output = sys.stdout.getvalue() # self.assertEqual(output, "1\n2\n3\n4\n5\n6\n7\n8\n") sys.stdout = io.StringIO() self.bst.bft_print(self.bst) output = sys.stdout.getvalue() self.assertTrue(output == "1\n8\n5\n3\n7\n2\n4\n6\n" or output == "1\n8\n5\n7\n3\n6\n4\n2\n") sys.stdout = io.StringIO() self.bst.dft_print(self.bst) output = sys.stdout.getvalue() self.assertTrue(output == "1\n8\n5\n7\n6\n3\n4\n2\n" or output == "1\n8\n5\n3\n2\n4\n7\n6\n") # # sys.stdout = io.StringIO() # self.bst.pre_order_dft(self.bst) # output = sys.stdout.getvalue() # self.assertEqual(output, "1\n8\n5\n3\n2\n4\n7\n6\n") # sys.stdout = io.StringIO() # self.bst.post_order_dft(self.bst) # output = sys.stdout.getvalue() # self.assertEqual(output, "2\n4\n3\n6\n7\n5\n8\n1\n") sys.stdout = stdout_ # Restore stdout
class TestBinarySearchTree(unittest.TestCase): def setUp(self): self.tree = BinarySearchTree() def test_basic_initialization_and_repr(self): self.assertEqual(repr(self.tree), '') def test_insert(self): self.tree.insert('C') self.assertEqual(repr(self.tree), 'C ') self.tree.insert('D') self.assertEqual(repr(self.tree), 'C D ') self.tree.insert('A') self.assertEqual(repr(self.tree), 'A C D ') self.tree.insert('B') self.assertEqual(repr(self.tree), 'A B C D ') self.tree.insert('F') self.assertEqual(repr(self.tree), 'A B C D F ') self.tree.insert('E') self.assertEqual(repr(self.tree), 'A B C D E F ') def test_iterator(self): letters = [] for node in self.tree: letters.append(node) self.assertEqual(letters, []) self.tree.insert('C') self.tree.insert('D') self.tree.insert('A') self.tree.insert('B') self.tree.insert('F') self.tree.insert('E') for node in self.tree: letters.append(node) self.assertEqual(letters, ['A', 'B', 'C', 'D', 'E', 'F']) def test_height(self): self.assertEqual(self.tree.height(self.tree.root), -1) self.tree.insert('C') self.assertEqual(self.tree.height(self.tree.root), 0) self.tree.insert('D') self.assertEqual(self.tree.height(self.tree.root), 1) self.tree.insert('A') self.assertEqual(self.tree.height(self.tree.root), 1) self.tree.insert('L') self.assertEqual(self.tree.height(self.tree.root), 2) self.tree.insert('X') self.assertEqual(self.tree.height(self.tree.root), 3) self.tree.insert('B') self.assertEqual(self.tree.height(self.tree.root), 3) def test_length(self): self.assertEqual(self.tree.length(), 0) self.assertEqual(len(self.tree), 0) self.tree.insert('C') self.assertEqual(self.tree.length(), 1) self.assertEqual(len(self.tree), 1) self.tree.insert('D') self.assertEqual(self.tree.length(), 2) self.assertEqual(len(self.tree), 2) self.tree.insert('A') self.assertEqual(self.tree.length(), 3) self.assertEqual(len(self.tree), 3) self.tree.insert('B') self.assertEqual(self.tree.length(), 4) self.assertEqual(len(self.tree), 4) self.tree.remove('D') self.assertEqual(self.tree.length(), 3) self.assertEqual(len(self.tree), 3) self.tree.remove('B') self.assertEqual(self.tree.length(), 2) self.assertEqual(len(self.tree), 2) self.tree.remove('A') self.assertEqual(self.tree.length(), 1) self.assertEqual(len(self.tree), 1) self.tree.remove('C') self.assertEqual(self.tree.length(), 0) self.assertEqual(len(self.tree), 0) def test_contains(self): self.tree.insert('C') self.tree.insert('D') self.tree.insert('A') self.assertTrue('A' in self.tree) self.assertTrue('C' in self.tree) self.assertTrue('D' in self.tree) self.assertFalse('B' in self.tree) self.assertFalse(None in self.tree) def test_search(self): self.tree.insert('C') self.tree.insert('D') self.tree.insert('A') self.tree.insert('B') self.tree.insert('F') self.tree.insert('E') self.assertEqual(self.tree.search('A').data, 'A') self.assertEqual(self.tree.search('B').data, 'B') self.assertEqual(self.tree.search('C').data, 'C') self.assertEqual(self.tree.search('D').data, 'D') self.assertEqual(self.tree.search('E').data, 'E') self.assertEqual(self.tree.search('F').data, 'F') self.assertEqual(self.tree.search('G'), None) def test_remove(self): self.tree.insert('C') self.tree.insert('D') self.tree.insert('A') self.tree.insert('B') self.tree.insert('F') self.tree.insert('E') self.assertEqual(repr(self.tree), 'A B C D E F ') self.tree.remove('E') self.assertEqual(repr(self.tree), 'A B C D F ') self.tree.remove('B') self.assertEqual(repr(self.tree), 'A C D F ') self.tree.remove('A') self.assertEqual(repr(self.tree), 'C D F ') self.tree.remove('C') self.assertEqual(repr(self.tree), 'D F ') self.tree.remove('D') self.assertEqual(repr(self.tree), 'F ') self.tree.remove('F') self.assertEqual(repr(self.tree), '') def test_in_order(self): self.tree.insert('F') self.tree.insert('G') self.tree.insert('B') self.tree.insert('A') self.tree.insert('D') self.tree.insert('I') self.tree.insert('H') self.tree.insert('E') self.tree.insert('C') self.assertEqual(self.tree.in_order(self.tree.root), 'A B C D E F G H I ') def test_pre_order(self): self.tree.insert('F') self.tree.insert('G') self.tree.insert('B') self.tree.insert('A') self.tree.insert('D') self.tree.insert('I') self.tree.insert('H') self.tree.insert('E') self.tree.insert('C') self.assertEqual(self.tree.pre_order(self.tree.root), 'F B A D C E G I H ') def test_post_order(self): self.tree.insert('F') self.tree.insert('G') self.tree.insert('B') self.tree.insert('A') self.tree.insert('D') self.tree.insert('I') self.tree.insert('H') self.tree.insert('E') self.tree.insert('C') self.assertEqual(self.tree.post_order(self.tree.root), 'A C E D B H I G F ')
def __init__(self, inner_tree=None): self._innertree = BinarySearchTree() if not inner_tree else inner_tree
def setUp(self): self.tree = BinarySearchTree()
f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() duplicates = [] # Return the list of duplicates in this data structure # Replace the nested for loops below with your improvements # for name_1 in names_1: # for name_2 in names_2: # if name_1 == name_2: # duplicates.append(name_1) # Create and call a new node list for a binary search bst = BinarySearchTree('names') # Loop through all the names in the first list for name in names_1: # Insert names into our binary search tree bst.insert(name) # Loop through all the names in our second list for name in names_2: # If our first list contains any names from the second list if bst.contains(name): # Add those names to our duplicates list duplicates.append(name) end_time = time.time() print (f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")
from binary_search_tree import BinarySearchTree test = BinarySearchTree(100) for i in range(51, 153, 2): test.insert(i) testarr1 = [] testarr2 = [] testarr3 = [] def cb1(x): return testarr1.append(x) def cb2(x): return testarr2.append(x) def cb3(x): return testarr3.append(x) test.for_each_before(cb1) test.for_each_middle(cb2) test.for_each_after(cb3) print(f"For Each Before\n", testarr1) print(f"For Each Middle\n", testarr2) print(f"For Each After\n", testarr3)
import time from binary_search_tree import BinarySearchTree start_time = time.time() f = open('names_1.txt', 'r') names_1 = f.read().split("\n") # List containing 10000 names f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() names_bst = BinarySearchTree(names_1[0]) duplicates = [] # do two for loops # second loop will append identical names to the duplicates array for name_1 in names_1[1:]: # use the insert method from bst to add name_1 names_bst.insert(name_1) for name_2 in names_2: # if name_2 == to a name_1 insert the name with the bst method append! if names_bst.contains(name_2): duplicates.append(name_2) # for name_1 in names_1: # for name_2 in names_2: # if name_1 == name_2: # duplicates.append(name_1)
class BinarySearchTreeTests(unittest.TestCase): def setUp(self): self.bst = BinarySearchTree(5) def test_breadth_first_traversal_1(self): arr = [] cb = lambda x: arr.append(x) self.bst.breadth_first_for_each(cb) # self.assertEqual(arr, [5]) def test_breadth_first_traversal_2(self): arr = [] cb = lambda x: arr.append(x) self.bst.insert(3) self.bst.insert(4) self.bst.insert(10) self.bst.insert(9) self.bst.insert(11) self.bst.breadth_first_for_each(cb) self.assertEqual(arr, [5, 3, 10, 4, 9, 11])
f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() duplicates = [] # Return the list of duplicates in this data structure # Replace the nested for loops below with your improvements ##### BELOW CODE RUNS IN O(n^2) ########################## # for name_1 in names_1: # for name_2 in names_2: # if name_1 == name_2: # duplicates.append(name_1) # Put names_1 into tree names_1_bst = BinarySearchTree('M') #initialize tree for name_1 in names_1: names_1_bst.insert(name_1) # Search for each name in tree for name_2 in names_2: if names_1_bst.contains(name_2): duplicates.append(name_2) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds") # ---------- Stretch Goal ----------- # Python has built-in tools that allow for a very efficient approach to this problem # What's the best time you can accomplish? Thare are no restrictions on techniques or data
import time from binary_search_tree import BinarySearchTree start_time = time.time() f = open('names_1.txt', 'r') names_1 = f.read().split("\n") # List containing 10000 names f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() duplicates = [] # Return the list of duplicates in this data structure tree = BinarySearchTree("") # Add all names in names_1 to BST for name_1 in names_1: tree.insert(name_1) # Search in tree for names in names_2 and add to duplicates if found for name_2 in names_2: if tree.contains(name_2): duplicates.append(name_2) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds") # ---------- Stretch Goal ----------- # Python has built-in tools that allow for a very efficient approach to this problem
names_1 = f.read().split("\n") # List containing 10000 names f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() ''' Orignal code needed to be replaced duplicates = [] for name_1 in names_1: for name_2 in names_2: if name_1 == name_2: duplicates.append(name_1) ''' #New code start duplicates = [] names_1_tree = BinarySearchTree(names_1[0]) for i in range(1, len(names_1)): names_1_tree.insert(names_1[i]) for i in names_2: if names_1_tree.contains(i): duplicates.append(i) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds")
size = len(q) level = [] for i in range(0, size): cur = q.popleft() level.append(cur.val) if cur.left is not None: q.append(cur.left) if cur.right is not None: q.append(cur.right) result.append(level) return result if __name__ == "__main__": bt = BinarySearchTree() s = Solution() nums = [2, 1, 4, 6, 2, 3, 6] root = bt.build_binary_search_tree(nums) print s.levelOrder(root) nums = [2, 1, 3] root = bt.build_binary_search_tree(nums) print s.levelOrder(root) nums = [2, 1, 3, 4, 5] root = bt.build_binary_search_tree(nums) print s.levelOrder(root) nums = [3, 2, 1, 4, 5]
def insert_tree(data): root = Node(data[0], 'root') bst = BinarySearchTree(root) for i in data[1:]: bst.insert(i) return bst
def __init__(self, size=100, capacity=120): self.size = size self.capacity = capacity self.current_size = 0 self.stats_init() self.tree = BinarySearchTree()
def test_smaller_data_at_left_node(self): expected = TreeNode('4', TreeNode('2', None, None), None) self.assertTreeEqual(BinarySearchTree(['4', '2']).data(), expected)
def test_same_number_at_left_node(self): expected = TreeNode('4', TreeNode('4', None, None), None) self.assertTreeEqual(BinarySearchTree(['4', '4']).data(), expected)
names_1 = f.read().split("\n") # List containing 10000 names f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() duplicates = [] # Return the list of duplicates in this data structure # Replace the nested for loops below with your improvements # for name_1 in names_1: # for name_2 in names_2: # if name_1 == name_2: # duplicates.append(name_1) # The runtime before was 0(n^2) due to the loop nested in another loop and now it is O(n log n) tree = BinarySearchTree('') tree.insert_list(names_1) tree.check_for_duplicates(names_2, duplicates) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds") # ---------- Stretch Goal ----------- # Python has built-in tools that allow for a very efficient approach to this problem # What's the best time you can accomplish? Thare are no restrictions on techniques or data # structures, but you may not import any additional libraries that you did not write yourself.
def test_greater_number_at_right_node(self): expected = TreeNode('4', None, TreeNode('5', None, None)) self.assertTreeEqual(BinarySearchTree(['4', '5']).data(), expected)
f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() duplicates = [] # Return the list of duplicates in this data structure # Replace the nested for loops below with your improvements for name_1 in names_1: for name_2 in names_2: if name_1 == name_2: duplicates.append(name_1) '''Using binary search tree and the insert+append methods for stacks ''' from binary_search_tree import BinarySearchTree # Inserting the values into the tree bst = BinarySearchTree(names_1[0]) for name in names_1: bst.insert(name) duplicates = [] # using pythons .contains and getting any names that are in the binary search tree and appending them to # the list of duplicates for name in names_2: if bst.contains(name): duplicates.append(name) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds") # ---------- Stretch Goal ----------- # Python has built-in tools that allow for a very efficient approach to this problem
def test_can_sort_single_number(self): self.assertEqual(BinarySearchTree(['2']).sorted_data(), ['2'])
from binary_search_tree import BinarySearchTree start_time = time.time() f = open('names_1.txt', 'r') names_1 = f.read().split("\n") # List containing 10000 names f.close() f = open('names_2.txt', 'r') names_2 = f.read().split("\n") # List containing 10000 names f.close() duplicates = [] # Return the list of duplicates in this data structure binary_tree = BinarySearchTree('names') for names in names_1: binary_tree.insert(names) for name in names_2: if binary_tree.contains(name): duplicates.append(name) end_time = time.time() print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n") print(f"runtime: {end_time - start_time} seconds") # INITIAL RUNTIME: 6.331447124481201 seconds # OPTIMIZED RUNTIME: 0.10910296440124512 seconds
def test_can_sort_if_second_number_is_same_as_first(self): self.assertEqual( BinarySearchTree(['2', '2']).sorted_data(), ['2', '2'])
class BinarySearchTreeTests(unittest.TestCase): def setUp(self): self.bst = BinarySearchTree(5) def test_insert(self): self.bst.insert(2) self.bst.insert(3) self.bst.insert(7) self.bst.insert(6) self.assertEqual(self.bst.left.right.value, 3) self.assertEqual(self.bst.right.left.value, 6) def test_contains(self): self.bst.insert(2) self.bst.insert(3) self.bst.insert(7) self.assertTrue(self.bst.contains(7)) self.assertFalse(self.bst.contains(8)) def test_get_max(self): self.assertEqual(self.bst.get_max(), 5) self.bst.insert(30) self.assertEqual(self.bst.get_max(), 30) self.bst.insert(300) self.bst.insert(3) self.assertEqual(self.bst.get_max(), 300) def test_for_each(self): arr = [] cb = lambda x: arr.append(x) v1 = random.randint(1, 101) v2 = random.randint(1, 101) v3 = random.randint(1, 101) v4 = random.randint(1, 101) v5 = random.randint(1, 101) self.bst.for_each(cb) self.assertTrue(5 in arr) self.assertTrue(v1 in arr) self.assertTrue(v2 in arr) self.assertTrue(v3 in arr) self.assertTrue(v4 in arr) self.assertTrue(v5 in arr)
def test_can_sort_if_second_number_is_greater_than_first(self): self.assertEqual( BinarySearchTree(['2', '3']).sorted_data(), ['2', '3'])
def test_handle_dupe_insert(self): self.bst2 = BinarySearchTree(1) self.bst2.insert(1) self.assertEqual(self.bst2.right.value, 1)
def test_can_sort_complex_tree(self): self.assertEqual( BinarySearchTree(['2', '1', '3', '6', '7', '5']).sorted_data(), ['1', '2', '3', '5', '6', '7'])
def main(): args = parse_argument() log.debug(args) if args.max_num == 3: from test_binary_search_tree import three_data as data elif args.max_num == 5: from test_binary_search_tree import five_data as data elif args.max_num == 8: from test_binary_search_tree import eight_data as data elif args.max_num == 12: from test_binary_search_tree import twelve_data as data elif args.max_num == 17: from test_binary_search_tree import seventeen_data as data else: data = list(random.sample(range(args.max_num), args.max_num)) log.info(data) first = data.pop(0) root = Node(first, 'root') bst = BinarySearchTree(root) for i in data: bst.insert(i) print('=== initial tree structure ===') bst.show() if args.target_key is not None: set_parent(bst.root) key = args.target_key node = bst.search(key) print('search:', node) if node.attr == 'left' or node.attr == 'root': print('=== target %d, rotating left ===' % key) rotate_left(node, bst) bst.show() print('=== target %d, rotating right ===' % node.parent.key) rotate_right(node.parent, bst) bst.show() elif node.attr == 'right': print('=== target %d, rotating right ===' % key) rotate_right(node, bst) bst.show() print('=== target %d, rotating left ===' % node.parent.key) rotate_left(node.parent, bst) bst.show()
def test_data_is_retained(self): expected = TreeNode('4', None, None) self.assertTreeEqual(BinarySearchTree(['4']).data(), expected)
bt.add(7) bt.add(6) bt.add(9) bt.add(15) bt.add(12) bt.add(11) bt.add(14) bt.add(17) bt.add(16) bt.add(19) # small tree if False: bt = BinarySearchTree() bt.add('a') bt.add('d') bt.add('e') bt.add('f') bt.add('b') bt.add('c') bt.show_all() bt.show_all_visual() for e in ['a','e','j']: check_for(bt,e) print
class SplayTree: def __init__(self, inner_tree=None): self._innertree = BinarySearchTree() if not inner_tree else inner_tree def __setitem__(self, key, value): self._innertree[key] = value self.__splay(key) def __getitem__(self, key): if self._innertree.key != key: # upgrade to root self.__splay(key) # we only bother in getting the value _if_ we splayed with success, otherwise # the element doesn't exist if self._innertree.key == key: return self._innertree[key] def __delitem__(self, key): self.__splay(key) # we do this test for the same reason we do it in __getitem__ if self._innertree.key == key: del self._innertree[key] def __splay(self, key): subtree = self._innertree._getsubtree(key) if subtree: while not subtree.parent is None: if self.__should_zig(subtree): # parent is root self.__zig(subtree) elif self.__should_zigzig(subtree): # both element and parent are on the same subtree self.__zigzig(subtree) else: # element is one subtree, parent is in another self.__zigzag(subtree) self._innertree = subtree def __zig(self, subtree): parent = subtree.parent gparent = subtree.parent.parent if gparent and self.__isleftchild(parent): gparent.left = subtree elif gparent and self.__isrightchild(parent): gparent.right = subtree # rotate to the right if node is left child if self.__isleftchild(subtree): rightside = subtree.right subtree.right = parent parent.parent = subtree parent.left = rightside subtree.parent = gparent # rotate to the left if node is right child elif self.__isrightchild(subtree): leftside = subtree.left subtree.left = parent parent.parent = subtree parent.right = leftside subtree.parent = gparent def __zigzig(self, subtree): self.__zig(subtree.parent) self.__zig(subtree) def __zigzag(self, subtree): self.__zig(subtree) self.__zig(subtree) def __should_zig(self, subtree): return subtree.parent.parent is None def __should_zigzig(self, subtree): return self.__bothleft(subtree, subtree.parent) or self.__bothright(subtree, subtree.parent) def __isleftchild(self, subtree): return subtree.parent.left == subtree def __isrightchild(self, subtree): return subtree.parent.right == subtree def __bothleft(self, subtree1, subtree2): return self.__isleftchild(subtree1) and self.__isleftchild(subtree2) def __bothright(self, subtree1, subtree2): return self.__isrightchild(subtree1) and self.__isrightchild(subtree2)