structure: set (TheAlgorithms#111)

* structure: set

* fix: hash_set implements isolated set interface

* improvement: adds general abstraction

* fix: renames & refactors testing

* feat: resolves requested changes

Author: zFl4wless

data_structures/hashing/hash_table.ts renamed to data_structures/hashing/hash_map.ts

@@ -1,19 +1,21 @@
+import { Map } from "../map";
+
 /**
- * Represents a hash table.
+ * Represents a hash map.
  * Time complexity:
  * - Set, Get, Delete, Has: O(1) on average, O(n) in the worst case.
  * - Clear: O(m) where m is the number of buckets.
  * - Keys, Values, Entires: O(n + m).
  *
  * @template K The key type.
  * @template V The value type.
- * @param size The size of the hash table.
+ * @param size The size of the hash map.
  * @param buckets The buckets in which to store the key-value pairs.
- * @param loadFactor The load factor to determine when to resize the hash table.
+ * @param loadFactor The load factor to determine when to resize the hash map.
  */
-export class HashTable<K, V> {
+export class HashMap<K, V> implements Map<K, V> {
     private size!: number;
-    private buckets!: HashTableEntry<K, V>[][];
+    private buckets!: HashMapEntry<K, V>[][];
     private readonly loadFactor = 0.75;
 
     constructor() {
@@ -45,7 +47,7 @@ export class HashTable<K, V> {
         const bucket = this.buckets[index];
 
         if (bucket.length === 0) {
-            bucket.push(new HashTableEntry(key, value));
+            bucket.push(new HashMapEntry(key, value));
             this.size++;
             return;
         }
@@ -57,7 +59,7 @@ export class HashTable<K, V> {
             }
         }
 
-        bucket.push(new HashTableEntry(key, value));
+        bucket.push(new HashMapEntry(key, value));
         this.size++;
     }
 
@@ -118,7 +120,7 @@ export class HashTable<K, V> {
     }
 
     /**
-     * Clears the hash table.
+     * Clears the hash map.
      */
     clear(): void {
         this.size = 0;
@@ -162,8 +164,8 @@ export class HashTable<K, V> {
      *
      * @returns The entries.
      */
-    entries(): HashTableEntry<K, V>[] {
-        const entries: HashTableEntry<K, V>[] = [];
+    entries(): HashMapEntry<K, V>[] {
+        const entries: HashMapEntry<K, V>[] = [];
         for (const bucket of this.buckets) {
             for (const entry of bucket) {
                 entries.push(entry);
@@ -204,7 +206,7 @@ export class HashTable<K, V> {
     }
 
     /**
-     * Resizes the hash table by doubling the amount of buckets.
+     * Resizes the hash map by doubling the amount of buckets.
      */
     private resize(): void {
         this.initializeBuckets(this.buckets.length * 2);
@@ -224,7 +226,7 @@ export class HashTable<K, V> {
  * @param key The key.
  * @param value The value.
  */
-class HashTableEntry<K, V> {
+export class HashMapEntry<K, V> {
     key: K;
     value: V;
 

data_structures/hashing/hash_map_set.ts

@@ -0,0 +1,24 @@
+import { Map } from "../map";
+import { MapSet } from "../map_set";
+import { HashMap } from "./hash_map";
+
+/**
+ * This class is a representation of the Set data structure based on a hash map.
+ *
+ * @template K The value type.
+ * @extends MapSet<K>
+ */
+export class HashMapSet<K> extends MapSet<K> {
+    constructor() {
+        super();
+    }
+
+    /**
+     * Initializes the map used to store the set.
+     *
+     * @returns {Map<K, null>} The map used to store the set.
+     */
+    protected initMap(): Map<K, null> {
+        return new HashMap<K, null>();
+    }
+}

data_structures/hashing/test/hash_map.test.ts

@@ -0,0 +1,91 @@
+import { HashMap } from "../hash_map";
+
+describe("Hash Map", () => {
+    let hashMap: HashMap<string, number>;
+    beforeEach(() => {
+        hashMap = new HashMap();
+    });
+
+    it("should set a value", () => {
+        hashMap.set("a", 1);
+
+        expect(hashMap.values()).toEqual([1]);
+    });
+
+    it("should override a value", () => {
+        hashMap.set("a", 1);
+        hashMap.set("a", 2);
+
+        expect(hashMap.values()).toEqual([2]);
+    });
+
+    it("should get a value", () => {
+        hashMap.set("a", 1);
+
+        expect(hashMap.get("a")).toBe(1);
+    });
+
+    it("should get null if key does not exist", () => {
+        expect(hashMap.get("a")).toBeNull();
+    });
+
+    it("should delete a value", () => {
+        hashMap.set("a", 1);
+        hashMap.delete("a");
+
+        expect(hashMap.get("a")).toBeNull();
+    });
+
+    it("should do nothing on delete if key does not exist", () => {
+        hashMap.delete("a");
+
+        expect(hashMap.get("a")).toBeNull();
+    });
+
+    it("should return true if key exists", () => {
+        hashMap.set("a", 1);
+
+        expect(hashMap.has("a")).toBe(true);
+    });
+
+    it("should return false if key does not exist", () => {
+        expect(hashMap.has("a")).toBe(false);
+    });
+
+    it("should clear the hash table", () => {
+        hashMap.set("a", 1);
+        hashMap.set("b", 2);
+        hashMap.set("c", 3);
+        hashMap.clear();
+
+        expect(hashMap.getSize()).toBe(0);
+    });
+
+    it("should return all keys", () => {
+        hashMap.set("a", 1);
+        hashMap.set("b", 2);
+        hashMap.set("c", 3);
+
+        expect(hashMap.keys()).toEqual(["a", "b", "c"]);
+    });
+
+    it("should return all values", () => {
+        hashMap.set("a", 1);
+        hashMap.set("b", 2);
+        hashMap.set("c", 3);
+
+        expect(hashMap.values()).toEqual([1, 2, 3]);
+    });
+
+    it("should return all key-value pairs", () => {
+        hashMap.set("a", 1);
+        hashMap.set("b", 2);
+        hashMap.set("c", 3);
+
+        expect(hashMap.entries()).toEqual([
+            { key: "a", value: 1 },
+            { key: "b", value: 2 },
+            { key: "c", value: 3 },
+        ]);
+    });
+});

data_structures/hashing/test/hash_table.test.ts

@@ -0,0 +1,16 @@
+import { HashMapEntry } from "./hashing/hash_map";
+
+/**
+ * This interface is a representation of the Map data structure.
+ */
+export interface Map<K, V> {
+    getSize(): number;
+    set(key: K, value: V): void;
+    get(key: K): V | null;
+    delete(key: K): void;
+    has(key: K): boolean;
+    clear(): void;
+    keys(): K[];
+    values(): V[];
+    entries(): HashMapEntry<K, V>[];
+}

data_structures/map.ts

@@ -0,0 +1,75 @@
+import { Map } from "./map";
+import { Set } from "./set";
+
+/**
+ * This class is a representation of the Set data structure based on a hash map.
+ *
+ * @template K The value type.
+ * @implements Set<K>
+ * @property {Map<K, null>} map The map used to store the set.
+ */
+export abstract class MapSet<K> implements Set<K> {
+    private map: Map<K, null>;
+
+    constructor() {
+        this.map = this.initMap();
+    }
+
+    /**
+     * Initializes the map used to store the set.
+     */
+    protected abstract initMap(): Map<K, null>;
+
+    /**
+     * Adds a new element to the set.
+     *
+     * @param value The value to add to the set.
+     */
+    add(value: K): void {
+        this.map.set(value, null);
+    }
+
+    /**
+     * Removes an element from the set.
+     *
+     * @param value The value to remove from the set.
+     */
+    delete(value: K): void {
+        this.map.delete(value);
+    }
+
+    /**
+     * Checks if the set contains a given value.
+     *
+     * @param value The value to check for.
+     * @returns Whether the set contains the value.
+     */
+    has(value: K): boolean {
+        return this.map.has(value);
+    }
+
+    /**
+     * Removes all elements from the set.
+     */
+    clear(): void {
+        this.map.clear();
+    }
+
+    /**
+     * Returns an array of all the values in the set.
+     *
+     * @returns An array of all the values in the set.
+     */
+    values(): K[] {
+        return this.map.keys();
+    }
+
+    /**
+     * Returns the number of elements in the set.
+     *
+     * @returns The number of elements in the set.
+     */
+    getSize(): number {
+        return this.map.getSize();
+    }
+}

data_structures/map_set.ts

@@ -0,0 +1,11 @@
+/**
+ * This interface is a representation of the Set data structure.
+ */
+export interface Set<K> {
+    getSize(): number;
+    add(value: K): void;
+    delete(value: K): void;
+    has(value: K): boolean;
+    clear(): void;
+    values(): K[];
+}