Added preliminary hashtable implementation and unit tests for everything thus far.

Author: calebmadrigal

README.md

@@ -1,4 +1,12 @@
 # Algorithm Implementations
 
-This is just a collection of algorithms I wanted to implement in order to improve my understanding. They are not optimized and probably shouldn't be used in production code.
+This is just a collection of algorithms I wanted to implement in order to improve my understanding. They are NOT optimized and probably shouldn't be used in production code.
+
+To run tests for a specific module:
+
+    python3 <module_name>.py
+
+To run all unit tests:
+
+    python3 -m unittest discover test
 

hashtable.py

@@ -1,11 +1,68 @@
+############ HashTable helper functions
 def hash_function(key_str, size):
     return sum([ord(c) for c in key_str]) % size
 
-if __name__ == "__main__":
-    test_inputs = ["a", "caleb", "test", "more than a feeling"]
 
-    hash_func = lambda key: hash_function(key, 10)
-    print(map(hash_func, test_inputs))
+############ HashTable class
+class HashTable:
+    """ Hash table which uses strings for keys. Value can be any object. """
+
+    def __init__(self, capacity=1000):
+        """ Capacity defaults to 1000. """
+
+        self.capacity = capacity
+        self.size = 0
+        # Storage format: [ [ [key1, value], [key2, value] ], [ [key3, value] ] ]
+        # The outmost list is the one which the hash function maps the index to. The next inner
+        # Array is the list of objects in that storage cell. The 3rd level is the individual
+        # item array, where the 1st item is the key, and the 2nd item is the value.
+        self.data = [[] for i in range(capacity)]
+
+    def set(self, key, obj):
+        """ Insert object with key into hashtable. If key already exists, then the object will be
+        updated. Key must be a string. Returns self. """
+
+        index = hash_function(key, self.capacity)
+        storage_cell = self.data[index]
+        for item in storage_cell:
+            if item[0] == key:
+                item[1] = obj
+        else:
+            storage_cell.append([key, obj])
+            self.size += 1
+
+        return self
+
+    def get(self, key):
+        """ Get object with key (key must be a string). If not found, it will raise a KeyError. """
+
+        index = hash_function(key, self.capacity)
+        storage_cell = self.data[index]
+        for item in storage_cell:
+            if item[0] == key:
+                return item[1]
+        else:
+            raise KeyError(key)
+
+    def remove(self, key):
+        """ Remove the object associated with key from the hashtable. If found, the object will
+        be returned. If not found, KeyError will be raised. """
+
+        index = hash_function(key, self.capacity)
+        storage_cell = self.data[index]
+        item_to_remove = None
+        for item in storage_cell:
+            if item[0] == key:
+                item_to_remove = item
+        if item_to_remove:
+                storage_cell.remove(item)
+                self.size -= 1
+                return item[1]
+        else:
+            raise KeyError(key)
+
+if __name__ == "__main__":
+    import unittest
+    testsuite = unittest.TestLoader().discover('test', pattern="*hashtable*")
+    unittest.TextTestRunner(verbosity=1).run(testsuite)
 
-    hash_func = lambda key: hash_function(key, 4)
-    print(map(hash_func, test_inputs))

mergesort.py

@@ -37,8 +37,7 @@ def mergesort(lst):
 
 
 if __name__ == "__main__":
-    import random
-    data = [random.randint(0,10) for i in range(9)]
-    print('UNSORTED:', data)
-    print('SORTED:  ', mergesort(data))
+    import unittest
+    testsuite = unittest.TestLoader().discover('test', pattern="*mergesort*")
+    unittest.TextTestRunner(verbosity=1).run(testsuite)
 

quicksort.py

@@ -19,8 +19,7 @@ def quicksort(lst):
         return quicksort(low) + [pivot] + quicksort(high)
 
 if __name__ == "__main__":
-    import random
-    data = [random.randint(0,10) for i in range(9)]
-    print('UNSORTED:', data)
-    print('SORTED:  ', quicksort(data))
+    import unittest
+    testsuite = unittest.TestLoader().discover('test', pattern="*quicksort*")
+    unittest.TextTestRunner(verbosity=1).run(testsuite)
 

test/test_hashtable.py

@@ -0,0 +1,73 @@
+import unittest
+import sys
+import os.path
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir)))
+import hashtable
+
+
+class HashFunctionTest(unittest.TestCase):
+
+    def test(self):
+        hash10 = lambda key: hashtable.hash_function(key, 10)
+        self.assertIn(hash10("a"), range(10))
+        self.assertIn(hash10("b"), range(10))
+        self.assertIn(hash10("caleb"), range(10))
+        self.assertIn(hash10("more than a feeling"), range(10))
+
+        hash4 = lambda key: hashtable.hash_function(key, 4)
+        self.assertIn(hash4("a"), range(4))
+        self.assertIn(hash4("b"), range(4))
+        self.assertIn(hash4("caleb"), range(4))
+        self.assertIn(hash4("more than a feeling"), range(4))
+
+
+class HashTableTest(unittest.TestCase):
+    def testCreate(self):
+        ht = hashtable.HashTable(10)
+        self.assertEqual(ht.capacity, 10)
+        self.assertEqual(ht.size, 0)
+
+        ht = hashtable.HashTable()
+        self.assertEqual(ht.capacity, 1000)
+
+    def testSetAndGet(self):
+        ht = hashtable.HashTable(10)
+        ht.set('a', 1)
+        self.assertEqual(ht.get('a'), 1)
+        self.assertEqual(ht.size, 1)
+
+        ht.set('a', 2)
+        self.assertEqual(ht.get('a'), 2)
+        #self.assertEqual(ht.size, 1)
+
+        ht.set('b', 10)
+        self.assertEqual(ht.get('b'), 10)
+        self.assertEqual(ht.get('a'), 2)
+        #self.assertEqual(ht.size, 2)
+
+        # Assert ht.set returns itself (for fluent calls)
+        self.assertEqual(ht.set('c', 5), ht)
+
+        ht.set('d', 100).set('e', 200).set('f', 300)
+        self.assertEqual(ht.get('d'), 100)
+        self.assertEqual(ht.get('e'), 200)
+        self.assertEqual(ht.get('f'), 300)
+
+    def testBadGet(self):
+        ht = hashtable.HashTable(10)
+        self.assertRaises(KeyError, ht.get, 'a')
+
+    def testRemove(self):
+        ht = hashtable.HashTable(10)
+        self.assertRaises(KeyError, ht.remove, 'a')
+
+        ht.set('a', 1)
+        removed_item = ht.remove('a')
+        self.assertEqual(removed_item, 1)
+        self.assertEqual(ht.size, 0)
+
+        
+if __name__ == '__main__':
+    unittest.main()
+

test/test_mergesort.py

@@ -0,0 +1,24 @@
+import unittest
+import sys
+import os.path
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir)))
+import mergesort
+
+
+class MergesortTest(unittest.TestCase):
+
+    def testSort(self):
+        a = [1,2,3,4,5,6,7,8,9]
+        self.assertEqual(mergesort.mergesort(a), [1,2,3,4,5,6,7,8,9])
+
+        b = [8,7,6,5,4,3,2,1]
+        self.assertEqual(mergesort.mergesort(b), [1,2,3,4,5,6,7,8])
+
+        c = [1,6,3,2,1,9,7,5,4,9]
+        self.assertEqual(mergesort.mergesort(c), [1,1,2,3,4,5,6,7,9,9])
+
+        
+if __name__ == '__main__':
+    unittest.main()
+

test/test_quicksort.py

@@ -0,0 +1,24 @@
+import unittest
+import sys
+import os.path
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), os.path.pardir)))
+import quicksort
+
+
+class QuicksortTest(unittest.TestCase):
+
+    def testSort(self):
+        a = [1,2,3,4,5,6,7,8,9]
+        self.assertEqual(quicksort.quicksort(a), [1,2,3,4,5,6,7,8,9])
+
+        b = [8,7,6,5,4,3,2,1]
+        self.assertEqual(quicksort.quicksort(b), [1,2,3,4,5,6,7,8])
+
+        c = [1,6,3,2,1,9,7,5,4,9]
+        self.assertEqual(quicksort.quicksort(c), [1,1,2,3,4,5,6,7,9,9])
+
+        
+if __name__ == '__main__':
+    unittest.main()
+