def test_iterator(): # Test with a hasht that has # [1]: a regular backing array element containing a simple KeyValuePair # [2]: a backing array element containing a LinkedList # [3]: another regular backing array element containing a simple KeyValuePair to make sure that we keep iterating # over the array after we've finished iterating over the list. hasht = hashtable.Hashtable( False ) # We don't want this Hashtable to grow and spread lists out during this test. hasht.put(1, "a") hasht.put(2, "b") hasht.put(22, "bb") hasht.put(3, "c") assert hasht.size() == 4 assert isinstance(hasht.backing_array[1], KeyValuePair) assert isinstance(hasht.backing_array[2], linked_list.LinkedList) assert isinstance(hasht.backing_array[3], KeyValuePair) py_dict = {} for keyValue in hasht: py_dict[keyValue.key] = keyValue.value assert len(py_dict) == hasht.size() == 4, \ 'len(py_dict) == {}, hasht.size() == {}'.format(len(py_dict), hasht.size()) assert py_dict.get(1, "a") assert py_dict.get(2, "b") assert py_dict.get(22, "bb") assert py_dict.get(3, "c")
def dfs(root): vertices_list = [] seen = hashtable.Hashtable() st = stack.Stack() st.push(root) while not st.is_empty(): vertex = st.pop() if seen.get(vertex.label) is not None: continue seen.put(vertex.label, 'dummy') vertices_list.append(vertex) for neighbor in vertex.get_neighbors(): if seen.get(neighbor.label) is None: st.push(neighbor) return vertices_list
def bfs(root): vertices_list = [] seen = hashtable.Hashtable() qu = queue1.Queue() qu.push(root) while not qu.is_empty(): vertex = qu.pop().value if seen.get(vertex.label) is not None: continue seen.put(vertex.label, 'dummy') vertices_list.append(vertex) for neighbor in vertex.get_neighbors(): if seen.get(neighbor.label) is None: qu.push(neighbor) return vertices_list
def create_hash_and_dict(): hash1 = hashtable.Hashtable() py_dict = {} STRESS_TEST_SIZE = 1000 for i in range(STRESS_TEST_SIZE): rand_num_key = generate_random_number() rand_num_value = generate_random_number() rand_str_key = generate_random_string() rand_str_value = generate_random_string() hash1.put(rand_num_key, rand_num_value) hash1.put(rand_str_key, rand_str_value) py_dict[rand_num_key] = rand_num_value py_dict[rand_str_key] = rand_str_value for i in hash1: hash1.remove(i.key) del py_dict[i.key] if hash1.size() == 500: break return hash1, py_dict
def test_Hashtable(): hasht = hashtable.Hashtable() # testing a key that i didn't insert is not in the hasht # i also test the size1 method from now on in many places in the code assert hasht.get(1) is None assert hasht.size() == 0 # testing basic put and get hasht.put(1, 1) assert hasht.size() == 1 assert hasht.get(1) == 1 # a key that its index calculates to the same bucket but is not in the hasht # (the bucket contains a KeyValuePair object) assert (compute_hash_code(11) % len(hasht.backing_array) == compute_hash_code(1) % len(hasht.backing_array)) assert type(hasht.backing_array[1]) == KeyValuePair assert hasht.get(11) is None assert hasht.size() == 1 # testing hash1 collision and resizing of the backing array assert "abc" != "acb" assert compute_hash_code("abc") == compute_hash_code("acb") hasht.put('abc', 2) assert hasht.size() == 2 hasht.put('cab', 3) assert hasht.size() == 3 assert hasht.get('abc') == 2 assert hasht.get('cab') == 3 # testing a key that will be stored in the same bucket as the keys above but is not in the hasht # (this time the bucket contains a linked list) assert type(hasht.backing_array[4]) == linked_list.LinkedList assert hasht.get('bac') is None assert hasht.size() == 3 # showing that the index of the bucket that stores 'abc' and 'bac' is 4 for later testing assert (compute_hash_code("abc") % len(hasht.backing_array) == compute_hash_code("acb") % len(hasht.backing_array) == 4) # i add another key that will be stored in the same bucket as 'abc and 'bac' to test the put method # when the backing array bucket has a linked list - test for second collision hasht.put('acb', 1) assert hasht.size() == 4 # testing resizing of the backing_array # since the number of elements are now more then 0.3*(length of backing array) assert len(hasht.backing_array) == 20 assert hasht.get('acb') == 1 # testing that putting the third key value pair in the same bucket didn't # change the other key value pairs in the bucket of index 4 assert hasht.get('abc') == 2 assert hasht.get('cab') == 3 # putting a value in a key that is already in the hasht in a bucket that contains # a KeyValuePair object # testing update to a key assert hasht.get(1) is not None assert type(hasht.backing_array[1]) == KeyValuePair hasht.put(1, 2) assert hasht.get(1) == 2 assert hasht.size() == 4 # putting a value in a key that is already in the hasht and is in a linked list of KeyValuePair objects # testing update to a key assert hasht.get('abc') is not None assert type(hasht.backing_array[14]) == linked_list.LinkedList hasht.put('abc', 8) assert hasht.get('abc') == 8 assert hasht.size() == 4 # testing hashtable_representation method and resizing of backing array assert hasht.hashtable_representation() == [ 0, 1, [1, 2], 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ['abc', 8], ['cab', 3], ['acb', 1], 15, 16, 17, 18, 19 ] # testing remove method # single KeyValuePair in backing array location assert type(hasht.backing_array[1]) == KeyValuePair assert hasht.remove(1) assert len(hasht.backing_array) == 10 assert hasht.get(1) is None assert hasht.size() == 3 # more then two KeyValuePairs in backing array location assert type(hasht.backing_array[4]) == linked_list.LinkedList assert hasht.remove('cab') assert hasht.get('cab') is None assert hasht.size() == 2 # test that all the key value pairs in the hasht are still in the right places. # also that resizing of backing array is correct assert hasht.hashtable_representation() == [ 0, 1, 2, 3, 4, ['abc', 8], ['acb', 1], 5, 6, 7, 8, 9 ] assert not hasht.remove(2) assert hasht.size() == 2 # test of removing a key that is not in the hasht assert hasht.get(2) is None # test that all the key value pairs in the hasht are still in the right places assert hasht.hashtable_representation() == [ 0, 1, 2, 3, 4, ['abc', 8], ['acb', 1], 5, 6, 7, 8, 9 ] # removing a key in a bucket with exactly two keys. # checking consistence type of objects in a bucket with two KeyValuePair objects assert hasht.remove('acb') assert hasht.size() == 1 assert len(hasht.backing_array) == 10 assert type(hasht.backing_array[4]) == KeyValuePair assert hasht.remove('abc') assert hasht.size() == 0 assert hasht.backing_array[4] is None
def recursive_dfs(vertex): seen = hashtable.Hashtable() vertices_list = [] Algorithms._recursive_dfs(vertex, vertices_list, seen) return vertices_list
def __init__(self): self.label2vertex = hashtable.Hashtable()