@raikuxq/alg-ds 1.0.2 → 1.1.0

package/README.md

@@ -30,6 +30,7 @@ Clone this repository and install dependencies by using `yarn` command.
   + [Stack](#stack)
   + [Queue](#queue)
 + [Non-linear data structures](#non-linear-data-structures)
+  + [Hash table](#hash-table)
   + [Graph](#graph)
   + [Binary tree](#binary-trees)
 
@@ -135,6 +136,17 @@ Extends [IConvertableToArray](src/types/IConvertableToArray.ts) interface.
 
 # Non linear data structures
 
+## Hash Table
+### Interfaces
+[IKeyValueStorage](src/types/IKeyValueStorage.ts) — Contains basic key-value storages operations.
+
+### Implementation
+[HashTableNode](src/data-structures/HashTable/HashTableNode.ts) — Contains key, data and isDeleted properties.
+
+[HashTable](src/data-structures/HashTable/HashTable.ts)  [ [ tests ] ](test/unit/data-structures/hash-table/hash-table.test.ts) — Implementation of open addressing hash table using quadratic probing
+
+
+
 ## Graph
 ### Interfaces
 [IGraph](src/types/IGraph.ts) — Contains basic graph operations.

package/package.json

@@ -30,6 +30,5 @@
     "typescript": "^4.0.3"
   },
   "dependencies": {},
-  "version": "1.0.2",
-  "type": "module"
+  "version": "1.1.0"
 }

package/src/data-structures/HashTable/HashTable.ts

@@ -0,0 +1,202 @@
+import IKeyValueStorage from "../../types/IKeyValueStorage";
+import HashTableNode from "./HashTableNode";
+
+/**
+ * Implementation of open addressing hash table using quadratic probing
+ */
+export default class HashTable<T> implements IKeyValueStorage<T> {
+  /**
+   Constants
+   */
+  private static DEFAULT_MAX_CAPACITY = 100;
+  private static MAX_LOAD_FACTOR = 0.5;
+
+  /**
+   * State
+   */
+  private storage: Array<HashTableNode<T>>;
+  private maxCapacity: number;
+  private storageCapacity = 0;
+
+  /**
+   * Given init capacity size will be used
+   * @throws when initial capacity value is not larger than 0
+   */
+  public constructor(initialCapacity: number = HashTable.DEFAULT_MAX_CAPACITY) {
+    if (initialCapacity <= 0) {
+      throw new Error("Size must be larger than 0");
+    }
+    this.maxCapacity = initialCapacity;
+    this.storage = new Array(this.maxCapacity).fill(null);
+  }
+
+  /**
+   * Main-hash function
+   */
+  private hashFn(key: string, number: number): number {
+    return (
+      (this.innerHashFn(key) + 127 * number + 365 * number * number) %
+      this.maxCapacity
+    );
+  }
+
+  /**
+   * Helper-hash function
+   */
+  private innerHashFn(key: string): number {
+    const length: number = key.length;
+
+    if (length === 0) {
+      return 0;
+    }
+    const substring = key.substring(0, length - 1);
+    const symbol = key.charCodeAt(length - 1);
+
+    return (127 * this.innerHashFn(substring) + symbol) % this.maxCapacity;
+  }
+
+  /**
+   * Max capacity will be increased and storage will be overwritten
+   */
+  private resizeStorage(): Array<HashTableNode<T>> {
+    this.maxCapacity *= 2;
+
+    const newArray = new Array(this.maxCapacity).fill(null);
+
+    for (let i = 0; i < this.storage.length; i++) {
+      const element = this.storage[i];
+
+      if (element != null) {
+        for (let j = 0; j < this.maxCapacity; j++) {
+          const newIndex = this.hashFn(element.key, j);
+
+          if (newArray[newIndex] == null) {
+            newArray[newIndex] = element;
+
+            break;
+          }
+        }
+      }
+    }
+
+    return newArray;
+  }
+
+  /**
+   * Will find node instance by its key
+   * @throws when element does not exist
+   */
+  private findNode(key: string): HashTableNode<T> {
+    for (let i = 0; i < this.maxCapacity; i++) {
+      const index = this.hashFn(key, i);
+      const node = this.storage[index];
+
+      if (node?.key === key) {
+        if (node?.isDeleted) {
+          break;
+        }
+        return node;
+      }
+    }
+
+    throw new Error("Element does not exist");
+  }
+
+  /**
+   * Will create new node instance and set in to storage by index
+   */
+  private addNode(key: string, data: T, index: number): void {
+    this.storage[index] = new HashTableNode<T>(key, data);
+
+    this.storageCapacity++;
+    const loadFactor = this.storageCapacity / this.maxCapacity;
+
+    if (loadFactor >= HashTable.MAX_LOAD_FACTOR) {
+      this.storage = this.resizeStorage();
+    }
+  }
+
+  /**
+   * Will create new node instance and set in to storage by index
+   */
+  private updateNode(data: T, index: number): void {
+    this.storage[index].data = data;
+    this.storage[index].isDeleted = false;
+  }
+
+  /**
+   * Will insert item to hash table
+   */
+  public set(key: string, data: T): void {
+    for (let i = 0; i < this.maxCapacity; i++) {
+      const index = this.hashFn(key, i);
+      const node = this.storage[index];
+
+      const shouldAddNode = node === null;
+      if (shouldAddNode) {
+        this.addNode(key, data, index);
+        break;
+      }
+
+      const shouldUpdateNode = node.key === key;
+      if (shouldUpdateNode) {
+        this.updateNode(data, index);
+        break;
+      }
+    }
+  }
+
+  /**
+   * Will update item property isDeleted to false
+   * @throws when element does not exist
+   */
+  public delete(key: string): void {
+    for (let i = 0; i < this.maxCapacity; i++) {
+      const index = this.hashFn(key, i);
+
+      if (this.storage[index] !== null) {
+        this.storage[index].isDeleted = true;
+        return;
+      }
+    }
+
+    throw new Error("Element does not exist");
+  }
+
+  /**
+   * Will find item in hash table
+   * @throws when element does not exist
+   */
+  public get(key: string): T {
+    return this.findNode(key).data;
+  }
+
+  /**
+   * Check if node with given key exists
+   */
+  public has(key: string): boolean {
+    try {
+      return Boolean(this.findNode(key));
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Added elements count
+   */
+  public length(): number {
+    const actualItems = this.storage.filter((item) => {
+      return item !== null && !item.isDeleted;
+    });
+
+    return actualItems.length;
+  }
+
+  /**
+   * Will overwrite storage with array of null elements
+   */
+  public clear(): void {
+    this.storage = new Array(HashTable.DEFAULT_MAX_CAPACITY).fill(null);
+  }
+}

package/src/data-structures/HashTable/HashTableNode.ts

@@ -0,0 +1,31 @@
+export default class HashTableNode<T> {
+  private readonly _key: string;
+  private _data: T;
+  private _isDeleted: boolean;
+
+  public constructor(key: string, data: T) {
+    this._key = key;
+    this._data = data;
+    this._isDeleted = false;
+  }
+
+  get data(): T {
+    return this._data;
+  }
+
+  set data(value: T) {
+    this._data = value;
+  }
+
+  get key(): string {
+    return this._key;
+  }
+
+  get isDeleted(): boolean {
+    return this._isDeleted;
+  }
+
+  set isDeleted(value: boolean) {
+    this._isDeleted = value;
+  }
+}

package/src/demo/demo.hashtable.ts

@@ -0,0 +1,28 @@
+import HashTable from "../data-structures/HashTable/HashTable";
+
+export const demoHashtable = (): void => {
+  const hashTable = new HashTable<number>(15);
+
+  // emulate 66% load
+  for (let i = 0; i < 10; i++) {
+    hashTable.set(`key${i * 2}`, i * 2);
+  }
+  console.log(hashTable);
+
+  for (let i = 10; i < 15; i++) {
+    hashTable.set(`key${i * 2}`, i * 2);
+  }
+  console.log(hashTable);
+  console.log("\n length:", hashTable.length());
+
+  hashTable.set("key4", 10000);
+  console.log("\n key4 value:", hashTable.get("key4"));
+  hashTable.delete("key4");
+  console.log("\n has key4:", hashTable.has("key4"));
+  hashTable.set("key4", 20000);
+  console.log("\n has key4:", hashTable.has("key4"));
+  console.log("\n key4 value:", hashTable.get("key4"));
+  console.log("\n", hashTable);
+  hashTable.clear();
+  console.log("\n", hashTable);
+};

package/src/demo/performance/hash-table.compare.ts

@@ -0,0 +1,40 @@
+import { perf, roundNumber } from "../../utils";
+import IKeyValueStorage from "../../types/IKeyValueStorage";
+import HashTable from "../../data-structures/HashTable/HashTable";
+
+export const pushToStorage = (
+  linearDS: IKeyValueStorage<number>,
+  elementsCount: number
+): void => {
+  for (let i = 0; i < elementsCount; i++) {
+    linearDS.set(`key${i}`, i);
+  }
+};
+
+export const perfHashTable = (): void => {
+  console.log(`HASHTABLE PERFORMANCE TEST:`);
+  const hashTable: IKeyValueStorage<number> = new HashTable<number>();
+  let elementsCount = 50;
+
+  while (elementsCount <= 5000000) {
+    pushToStorage(hashTable, elementsCount);
+
+    const perfSet = perf(() => {
+      hashTable.set(`key${elementsCount}`, elementsCount);
+    });
+    const perfGet = perf(() => {
+      hashTable.get(`key${elementsCount}`);
+    });
+
+    const perfHas = perf(() => {
+      hashTable.has(`key${elementsCount - 10}`);
+    });
+
+    console.log(`N: ${elementsCount} set: ${roundNumber(perfSet)}ms`);
+    console.log(`N: ${elementsCount} get: ${roundNumber(perfGet)}ms`);
+    console.log(`N: ${elementsCount} has: ${roundNumber(perfHas)}ms`);
+    console.log("=========================");
+
+    elementsCount *= 10;
+  }
+};

package/src/index.ts

@@ -1,40 +1,44 @@
-/**
- * Write your code here
- */
-// import { demoBst, demoBstObjects } from "./demo/demo.bst";
-// import { bstCompare } from "./demo/performance/bst-compare";
-// import { demoStack } from "./demo/demo.stack";
-// import { perfQueue, perfStack } from "./demo/performance/ds-compare";
-// import { demoLinkedList } from "./demo/demo.linked-list";
-// import { demoQueue } from "./demo/demo.queue";
-// import {
-//   demoDirectedGraph,
-//   demoGraphGenerated,
-//   demoUndirectedGraph,
-// } from "./demo/demo.graph";
-// import { demoLoopedArray } from "./demo/demo.looped-array";
-// import { compareAllSortTypes } from "./demo/performance/sort-compare";
-//
-// demoLinkedList();
-// // console.log("================================================================");
-// demoLoopedArray();
-// // console.log("================================================================");
-// demoQueue();
-// // console.log("================================================================");
-// demoStack();
-// // console.log("================================================================");
-// demoUndirectedGraph();
-// // console.log("================================================================");
-// demoDirectedGraph();
-// // console.log("================================================================");
-// demoGraphGenerated();
-// // console.log("================================================================");
-// compareAllSortTypes();
-// // console.log("===========================================================");
-// perfQueue();
-// // console.log("===========================================================");
-// perfStack();
-// // console.log("===========================================================");
-// demoBst();
-// // console.log("===========================================================");
-// bstCompare();
+/**
+ * Write your code here
+ */
+// import { demoHashtable } from "./demo/demo.hashtable";
+import { perfHashTable } from "./demo/performance/hash-table.compare";
+// import { demoBst, demoBstObjects } from "./demo/demo.bst";
+// import { bstCompare } from "./demo/performance/bst-compare";
+// import { demoStack } from "./demo/demo.stack";
+// import { perfQueue, perfStack } from "./demo/performance/ds-compare";
+// import { demoLinkedList } from "./demo/demo.linked-list";
+// import { demoQueue } from "./demo/demo.queue";
+// import {
+//   demoDirectedGraph,
+//   demoGraphGenerated,
+//   demoUndirectedGraph,
+// } from "./demo/demo.graph";
+// import { demoLoopedArray } from "./demo/demo.looped-array";
+// import { compareAllSortTypes } from "./demo/performance/sort-compare";
+//
+// demoLinkedList();
+// // console.log("================================================================");
+// demoLoopedArray();
+// // console.log("================================================================");
+// demoQueue();
+// // console.log("================================================================");
+// demoStack();
+// // console.log("================================================================");
+// demoUndirectedGraph();
+// // console.log("================================================================");
+// demoDirectedGraph();
+// // console.log("================================================================");
+// demoGraphGenerated();
+// // console.log("================================================================");
+// compareAllSortTypes();
+// // console.log("===========================================================");
+// perfQueue();
+// // console.log("===========================================================");
+// perfStack();
+// // console.log("===========================================================");
+// demoBst();
+// // console.log("===========================================================");
+// bstCompare();
+// demoHashtable();
+perfHashTable();

package/src/types/IKeyValueStorage.ts

@@ -0,0 +1,8 @@
+export default interface IKeyValueStorage<T> {
+  set(key: string, value: T): void;
+  has(key: string): boolean;
+  get(key: string): T;
+  delete(key: string): void;
+  length(): number;
+  clear(): void;
+}

package/test/unit/data-structures/hash-table/hash-table.test.ts

@@ -0,0 +1,176 @@
+import IKeyValueStorage from "../../../../src/types/IKeyValueStorage";
+import HashTable from "../../../../src/data-structures/HashTable/HashTable";
+
+describe("Hash Table", () => {
+  describe("constructor", () => {
+    it("should throw when given capacity value is less than 1", () => {
+      expect(() => {
+        new HashTable(-5);
+      }).toThrowError();
+    });
+
+    it("should create empty instance", () => {
+      const hashTable = new HashTable();
+      expect(hashTable.length()).toBe(0);
+    });
+  });
+
+  describe("method set", () => {
+    it("should support multiple data types", () => {
+      const hashTable: IKeyValueStorage<
+        number | string | number[]
+      > = new HashTable();
+      hashTable.set("myNumberProp", 5);
+      hashTable.set("myStringProp", "string");
+      hashTable.set("myArrayProp", [1, 2, 3, 4, 5]);
+
+      expect(hashTable.get("myNumberProp")).toBe(5);
+      expect(hashTable.get("myStringProp")).toBe("string");
+      expect(hashTable.get("myArrayProp")).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it("should correctly create new prop", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key", 5);
+
+      expect(hashTable.get("key")).toBe(5);
+    });
+
+    it("should correctly update value when it already exists", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key", 5);
+      hashTable.set("key", 10);
+
+      expect(hashTable.get("key")).toBe(10);
+    });
+
+    it("should be possible to create new nodes after deletion", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable(5);
+      hashTable.set("key1", 1);
+      hashTable.set("key2", 2);
+      hashTable.set("key3", 3);
+      hashTable.delete("key2");
+      hashTable.delete("key3");
+      hashTable.set("key4", 4);
+
+      expect(hashTable.get("key4")).toBe(4);
+    });
+
+    it("should correctly increase hashtable size when capacity >= 50% of max capacity", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable(5);
+      for (let i = 0; i < 15; i++) {
+        hashTable.set(`key${i}`, i);
+      }
+
+      expect(hashTable.length()).toBe(15);
+    });
+  });
+
+  describe("method has", () => {
+    it("should return false when hashtable is empty", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+
+      expect(hashTable.has("NOT_EXISTED_PROP")).toBe(false);
+    });
+
+    it("should return true when property is exists", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key", 5);
+
+      expect(hashTable.has("key")).toBe(true);
+    });
+
+    it("should return false after deletion", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key", 5);
+      hashTable.delete("key");
+
+      expect(hashTable.has("key")).toBe(false);
+    });
+  });
+
+  describe("method get", () => {
+    it("should throw when hashtable is empty", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+
+      expect(() => {
+        hashTable.get("key");
+      }).toThrowError();
+    });
+
+    it("should return true when property is exists", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key", 5);
+
+      expect(hashTable.get("key")).toBe(5);
+    });
+
+    it("should throw after property deletion", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key", 5);
+      hashTable.delete("key");
+
+      expect(() => {
+        hashTable.get("key");
+      }).toThrowError();
+    });
+  });
+
+  describe("method delete", () => {
+    it("should delete prop correctly", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key", 5);
+      hashTable.delete("key");
+
+      expect(hashTable.has("key")).toBe(false);
+    });
+
+    it("should throw when element does not exist", () => {
+      const hashTable = new HashTable();
+
+      expect(() => {
+        hashTable.delete("NOT_EXISTED_PROP");
+      }).toThrowError();
+    });
+  });
+
+  describe("method length", () => {
+    it("should return 0 when table is empty", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+
+      expect(hashTable.length()).toBe(0);
+    });
+
+    it("should return correct length value of added elements", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key1", 1);
+      hashTable.set("key2", 2);
+      hashTable.set("key3", 3);
+
+      expect(hashTable.length()).toBe(3);
+    });
+
+    it("should return updated length value after deletion", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key1", 1);
+      hashTable.set("key2", 2);
+      hashTable.set("key3", 3);
+      hashTable.delete("key1");
+
+      expect(hashTable.length()).toBe(2);
+    });
+  });
+
+  describe("method clear", () => {
+    it("should remove all elements", () => {
+      const hashTable: IKeyValueStorage<number> = new HashTable();
+      hashTable.set("key1", 1);
+      hashTable.set("key2", 2);
+      hashTable.clear();
+
+      expect(hashTable.length()).toBe(0);
+      expect(hashTable.has("key1")).toBe(false);
+      expect(hashTable.has("key2")).toBe(false);
+    });
+  });
+});