a/HashMaps
1
0
Fork 0
mirror of https://codeberg.org/andyscott/HashMaps.git synced 2024-09-17 22:48:08 -04:00
Code Issues Projects Releases Packages Wiki Activity
HashMaps/hash_map_oa.py

419 lines
13 KiB
Python
Raw Blame History

# Name: Andrew Scott
# OSU Email: scottand@oregonstate.edu
# Course: CS261 - Data Structures
# Assignment: 6
# Due Date: 2022-06-03
# Description: HashMap implementation using Open Addressing with Quadratic
# Probing
from a6_include import DynamicArray, HashEntry, hash_function_1, hash_function_2
class HashMap:
def __init__(self, capacity: int, function) -> None:
"""
Initialize new HashMap that uses
quadratic probing for collision resolution
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
self._buckets = DynamicArray()
for _ in range(capacity):
self._buckets.append(None)
self._capacity = capacity
self._hash_function = function
self._size = 0
def __str__(self) -> str:
"""
Override string method to provide more readable output
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
out = ""
for i in range(self._buckets.length()):
out += str(i) + ": " + str(self._buckets[i]) + "\n"
return out
def get_size(self) -> int:
"""
Return size of map
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
return self._size
def get_capacity(self) -> int:
"""
Return capacity of map
DO NOT CHANGE THIS METHOD IN ANY WAY
"""
return self._capacity
# ------------------------------------------------------------------ #
def put(self, key: str, value: object) -> None:
"""Adds (or updates) a key/value pair to the hash map
Parameters
----------
key : str
Identifier for the given value
value : object
Value to add, or update if the key is already present
"""
# remember, if the load factor is greater than or equal to 0.5,
# resize the table before putting the new key/value pair
if self.table_load() >= 0.5:
self.resize_table(self._capacity * 2)
hash = self._hash_function(key)
initial_index = hash % self._capacity
is_placed = False
quadratic_factor = 0
index = initial_index
while not is_placed:
if self._buckets[index] is None:
self._buckets[index] = HashEntry(key, value)
self._size += 1
is_placed = True
elif self._buckets[index].is_tombstone:
self._buckets[index].key = key
self._buckets[index].value = value
self._buckets[index].is_tombstone = False
is_placed = True
elif self._buckets[index].key == key:
self._buckets[index].value = value
is_placed = True
else:
quadratic_factor += 1
index = (initial_index + quadratic_factor**2) % self._capacity
def table_load(self) -> float:
"""Get the current hash table load factor
Returns
-------
float
The load factor
"""
return self._size / self._capacity
def empty_buckets(self) -> int:
"""Gets the number of empty buckets in the hash table
Returns
-------
int
Number of empty buckets
"""
count = 0
for i in range(self._buckets.length()):
entry = self._buckets[i]
if entry is None or entry.is_tombstone:
count += 1
return count
def resize_table(self, new_capacity: int) -> None:
"""Changes the capacity of the hash table
All existing key/value pairs remain and are rehashed. Does nothing if
the new capacity is less than 1.
Parameters
----------
new_capacity : int
New capacity for the hash table
"""
# immediately return if new_capacity is less than 1
if new_capacity < 1 or new_capacity < self._size:
return
# create new hash table
new_table = DynamicArray()
old_table = self._buckets
for i in range(new_capacity):
new_table.append(None)
self._buckets = new_table
self._size = 0
self._capacity = new_capacity
for i in range(old_table.length()):
if old_table[i] is not None and not old_table[i].is_tombstone:
self.put(old_table[i].key, old_table[i].value)
def get(self, key: str) -> object:
"""Get the value associated with a key
Parameters
----------
key : str
The key to look up in the hash map
Returns
-------
object
The value associated with the key if it exists, otherwise None
"""
for i in range(self._capacity):
if self._buckets[i] is not None and self._buckets[i].key == key:
return self._buckets[i].value
return None
def contains_key(self, key: str) -> bool:
"""Checks if a given key is in the hash map
Parameters
----------
key : str
Key to look up in the hash map
Returns
-------
bool
True if the key is in the hash map, otherwise False
"""
for i in range(self._capacity):
if self._buckets[i] is not None and self._buckets[i].key == key:
return True
return False
def remove(self, key: str) -> None:
"""Removes a key/value pair from the hash map
Parameters
----------
key : str
Key to look up in the hash map
"""
for i in range(self._capacity):
if self._buckets[i] is not None and self._buckets[i].key == key:
self._buckets[i].is_tombstone = True
self._size -= 1
def clear(self) -> None:
"""
TODO: Write this implementation
"""
self._buckets = DynamicArray()
self._size = 0
self._capacity = self._buckets.length()
for i in range(self._buckets.length()):
self._buckets.append(None)
def get_keys(self) -> DynamicArray:
"""Get an array that contains all the keys in the hash map
Returns
-------
DynamicArray
Array containing the hash maps keys
"""
keys = DynamicArray
for i in range(self._capacity):
if self._buckets[i] is not None:
keys.append(self._buckets[i].key)
# ------------------- BASIC TESTING ---------------------------------------- #
if __name__ == "__main__":
print("\nPDF - put example 1")
print("-------------------")
m = HashMap(50, hash_function_1)
for i in range(150):
m.put("str" + str(i), i * 100)
if i % 25 == 24:
print(m.empty_buckets(), m.table_load(), m.get_size(), m.get_capacity())
print("\nPDF - put example 2")
print("-------------------")
m = HashMap(40, hash_function_2)
for i in range(50):
m.put("str" + str(i // 3), i * 100)
if i % 10 == 9:
print(m.empty_buckets(), m.table_load(), m.get_size(), m.get_capacity())
print("\nPDF - table_load example 1")
print("--------------------------")
m = HashMap(100, hash_function_1)
print(m.table_load())
m.put("key1", 10)
print(m.table_load())
m.put("key2", 20)
print(m.table_load())
m.put("key1", 30)
print(m.table_load())
print("\nPDF - table_load example 2")
print("--------------------------")
m = HashMap(50, hash_function_1)
for i in range(50):
m.put("key" + str(i), i * 100)
if i % 10 == 0:
print(m.table_load(), m.get_size(), m.get_capacity())
print("\nPDF - empty_buckets example 1")
print("-----------------------------")
m = HashMap(100, hash_function_1)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key1", 10)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key2", 20)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key1", 30)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
m.put("key4", 40)
print(m.empty_buckets(), m.get_size(), m.get_capacity())
print("\nPDF - empty_buckets example 2")
print("-----------------------------")
m = HashMap(50, hash_function_1)
for i in range(150):
m.put("key" + str(i), i * 100)
if i % 30 == 0:
print(m.empty_buckets(), m.get_size(), m.get_capacity())
print("\nPDF - resize example 1")
print("----------------------")
m = HashMap(20, hash_function_1)
m.put("key1", 10)
print(m.get_size(), m.get_capacity(), m.get("key1"), m.contains_key("key1"))
m.resize_table(30)
print(m.get_size(), m.get_capacity(), m.get("key1"), m.contains_key("key1"))
print("\nPDF - resize example 2")
print("----------------------")
m = HashMap(75, hash_function_2)
keys = [i for i in range(1, 1000, 13)]
for key in keys:
m.put(str(key), key * 42)
print(m.get_size(), m.get_capacity())
for capacity in range(111, 1000, 117):
m.resize_table(capacity)
if m.table_load() >= 0.5:
print(
"Check that capacity gets updated during resize(); "
"don't wait until the next put()"
)
m.put("some key", "some value")
result = m.contains_key("some key")
m.remove("some key")
for key in keys:
# all inserted keys must be present
result &= m.contains_key(str(key))
# NOT inserted keys must be absent
result &= not m.contains_key(str(key + 1))
print(
capacity, result, m.get_size(), m.get_capacity(), round(m.table_load(), 2)
)
print("\nPDF - get example 1")
print("-------------------")
m = HashMap(30, hash_function_1)
print(m.get("key"))
m.put("key1", 10)
print(m.get("key1"))
print("\nPDF - get example 2")
print("-------------------")
m = HashMap(150, hash_function_2)
for i in range(200, 300, 7):
m.put(str(i), i * 10)
print(m.get_size(), m.get_capacity())
for i in range(200, 300, 21):
print(i, m.get(str(i)), m.get(str(i)) == i * 10)
print(i + 1, m.get(str(i + 1)), m.get(str(i + 1)) == (i + 1) * 10)
print("\nPDF - contains_key example 1")
print("----------------------------")
m = HashMap(10, hash_function_1)
print(m.contains_key("key1"))
m.put("key1", 10)
m.put("key2", 20)
m.put("key3", 30)
print(m.contains_key("key1"))
print(m.contains_key("key4"))
print(m.contains_key("key2"))
print(m.contains_key("key3"))
m.remove("key3")
print(m.contains_key("key3"))
print("\nPDF - contains_key example 2")
print("----------------------------")
m = HashMap(75, hash_function_2)
keys = [i for i in range(1, 1000, 20)]
for key in keys:
m.put(str(key), key * 42)
print(m.get_size(), m.get_capacity())
result = True
for key in keys:
# all inserted keys must be present
result &= m.contains_key(str(key))
# NOT inserted keys must be absent
result &= not m.contains_key(str(key + 1))
print(result)
print("\nPDF - remove example 1")
print("----------------------")
m = HashMap(50, hash_function_1)
print(m.get("key1"))
m.put("key1", 10)
print(m.get("key1"))
m.remove("key1")
print(m.get("key1"))
m.remove("key4")
print("\nPDF - clear example 1")
print("---------------------")
m = HashMap(100, hash_function_1)
print(m.get_size(), m.get_capacity())
m.put("key1", 10)
m.put("key2", 20)
m.put("key1", 30)
print(m.get_size(), m.get_capacity())
m.clear()
print(m.get_size(), m.get_capacity())
print("\nPDF - clear example 2")
print("---------------------")
m = HashMap(50, hash_function_1)
print(m.get_size(), m.get_capacity())
m.put("key1", 10)
print(m.get_size(), m.get_capacity())
m.put("key2", 20)
print(m.get_size(), m.get_capacity())
m.resize_table(100)
print(m.get_size(), m.get_capacity())
m.clear()
print(m.get_size(), m.get_capacity())
print("\nPDF - get_keys example 1")
print("------------------------")
m = HashMap(10, hash_function_2)
for i in range(100, 200, 10):
m.put(str(i), str(i * 10))
print(m.get_keys())
m.resize_table(1)
print(m.get_keys())
m.put("200", "2000")
m.remove("100")
m.resize_table(2)
print(m.get_keys())
Reference in a new issue View git blame Copy permalink