data-structure-typed 1.33.6 → 1.33.7

package/lib/data-structures/hash/hash-table.js

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export class HashNode {
+export class HashTableNode {
     constructor(key, val) {
         this.key = key;
         this.val = val;
@@ -13,94 +13,162 @@ export class HashNode {
     }
 }
 export class HashTable {
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
+    }
     get buckets() {
         return this._buckets;
     }
     set buckets(value) {
         this._buckets = value;
     }
-    get size() {
-        return this._size;
-    }
-    set size(value) {
-        this._size = value;
-    }
     get capacity() {
         return this._capacity;
     }
     set capacity(value) {
         this._capacity = value;
     }
+    constructor(capacity = HashTable.DEFAULT_CAPACITY, hashFn) {
+        this._hashFn = hashFn || this._defaultHashFn;
+        this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
+        this._size = 0;
+        this._buckets = new Array(this._capacity).fill(null);
+    }
     /**
-     * The constructor initializes the capacity, size, and buckets of an object.
-     * @param [capacity=1000] - The `capacity` parameter represents the maximum number of elements that the data structure
-     * can hold. It is an optional parameter with a default value of 1000.
+     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
+     * capacity of the data structure.
+     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
+     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
+     * function is used to
+     * @returns the hash value of the key modulo the capacity of the data structure.
      */
-    constructor(capacity = 1000) {
-        this._capacity = capacity;
-        this._size = 0;
-        this._buckets = new Array(this.capacity).fill(null);
+    _defaultHashFn(key) {
+        // Can be replaced with other hash functions as needed
+        const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
+        return hashValue % this._capacity;
     }
     /**
-     * The hash function takes a key, converts it to a string, calculates the sum of the ASCII values of its characters, and
-     * returns the remainder when divided by the capacity of the data structure.
-     * @param {K} key - The `key` parameter represents the key that needs to be hashed. It is of type `K`, which means it can
-     * be any data type that can be converted to a string.
-     * @returns The hash value of the key modulo the capacity of the data structure.
+     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
+     * string hash function.
+     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
+     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
+     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
      */
-    hash(key) {
+    _multiplicativeStringHashFn(key) {
         const keyString = String(key);
         let hash = 0;
         for (let i = 0; i < keyString.length; i++) {
-            hash += keyString.charCodeAt(i);
+            const charCode = keyString.charCodeAt(i);
+            // Some constants for adjusting the hash function
+            const A = 0.618033988749895;
+            const M = 1 << 30; // 2^30
+            hash = (hash * A + charCode) % M;
+        }
+        return Math.abs(hash); // Take absolute value to ensure non-negative numbers
+    }
+    /**
+     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
+     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
+     * type, but it will be converted to a string using the `String()` function before calculating the hash.
+     * @returns a number, which is the hash value calculated for the given key.
+     */
+    _murmurStringHashFn(key) {
+        const keyString = String(key);
+        const seed = 0;
+        let hash = seed;
+        for (let i = 0; i < keyString.length; i++) {
+            const char = keyString.charCodeAt(i);
+            hash = (hash ^ char) * 0x5bd1e995;
+            hash = (hash ^ (hash >>> 15)) * 0x27d4eb2d;
+            hash = hash ^ (hash >>> 15);
+        }
+        return Math.abs(hash);
+    }
+    /**
+     * The _hash function takes a key and returns a number.
+     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
+     * @returns The hash function is returning a number.
+     */
+    _hash(key) {
+        return this.hashFn(key);
+    }
+    /**
+     * The function calculates a hash value for a given string using the djb2 algorithm.
+     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
+     * which we want to calculate the hash value.
+     * @returns a number, which is the hash value of the input string.
+     */
+    _stringHash(key) {
+        let hash = 0;
+        for (let i = 0; i < key.length; i++) {
+            hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
         }
-        return hash % this.capacity;
+        return hash;
+    }
+    /**
+     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
+     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
+     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
+     * the key, which can be used for
+     * @returns a number, which is the hash value of the key.
+     */
+    _objectHash(key) {
+        // If the key is an object, you can write a custom hash function
+        // For example, convert the object's properties to a string and use string hashing
+        // This is just an example; you should write a specific object hash function as needed
+        return this._stringHash(JSON.stringify(key));
     }
     /**
-     * The put function adds a key-value pair to a hash table, handling collisions by chaining.
+     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
      * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
-     * table. It is of type K, which can be any data type that can be used as a key, such as a string, number, or object.
-     * @param {V} val - The `val` parameter represents the value associated with the key in the hash table.
-     * @returns Nothing is being returned. The return type of the function is void, which means it does not return any value.
+     * table. It is of type K, which is a generic type representing the key's data type.
+     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * table.
+     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
+     * value.
      */
-    put(key, val) {
-        const index = this.hash(key);
-        const newNode = new HashNode(key, val);
-        if (!this.buckets[index]) {
-            this.buckets[index] = newNode;
+    set(key, val) {
+        const index = this._hash(key);
+        const newNode = new HashTableNode(key, val);
+        if (!this._buckets[index]) {
+            this._buckets[index] = newNode;
         }
         else {
-            // Handle collision by chaining
-            let currentNode = this.buckets[index];
-            while (currentNode.next) {
+            // Handle collisions, consider using open addressing, etc.
+            let currentNode = this._buckets[index];
+            while (currentNode) {
                 if (currentNode.key === key) {
-                    // Update the val if the key already exists
+                    // If the key already exists, update the value
                     currentNode.val = val;
                     return;
                 }
+                if (!currentNode.next) {
+                    break;
+                }
                 currentNode = currentNode.next;
             }
-            if (currentNode.key === key) {
-                // Update the val if the key already exists (last node)
-                currentNode.val = val;
-            }
-            else {
-                // Add the new node to the end of the chain
-                currentNode.next = newNode;
-            }
+            // Add to the end of the linked list
+            currentNode.next = newNode;
+        }
+        this._size++;
+        // If the load factor is too high, resize the hash table
+        if (this._size / this._capacity >= HashTable.LOAD_FACTOR) {
+            this._expand();
         }
-        this.size++;
     }
     /**
      * The `get` function retrieves the value associated with a given key from a hash table.
-     * @param {K} key - The parameter "key" represents the key of the element that we want to retrieve from the data
+     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
      * structure.
      * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
      * not found, it returns `undefined`.
      */
     get(key) {
-        const index = this.hash(key);
-        let currentNode = this.buckets[index];
+        const index = this._hash(key);
+        let currentNode = this._buckets[index];
         while (currentNode) {
             if (currentNode.key === key) {
                 return currentNode.val;
@@ -110,15 +178,15 @@ export class HashTable {
         return undefined; // Key not found
     }
     /**
-     * The `remove` function removes a key-value pair from a hash table.
+     * The remove function removes a key-value pair from a hash table.
      * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
      * table.
      * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
      * any value.
      */
     remove(key) {
-        const index = this.hash(key);
-        let currentNode = this.buckets[index];
+        const index = this._hash(key);
+        let currentNode = this._buckets[index];
         let prevNode = null;
         while (currentNode) {
             if (currentNode.key === key) {
@@ -126,13 +194,47 @@ export class HashTable {
                     prevNode.next = currentNode.next;
                 }
                 else {
-                    this.buckets[index] = currentNode.next;
+                    this._buckets[index] = currentNode.next;
                 }
-                this.size--;
+                this._size--;
+                currentNode.next = null; // Release memory
                 return;
             }
             prevNode = currentNode;
             currentNode = currentNode.next;
         }
     }
+    /**
+     * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
+     * capacity and rehashing all the existing key-value pairs into the new buckets.
+     */
+    _expand() {
+        const newCapacity = this._capacity * 2;
+        const newBuckets = new Array(newCapacity).fill(null);
+        for (const bucket of this._buckets) {
+            let currentNode = bucket;
+            while (currentNode) {
+                const newIndex = this._hash(currentNode.key);
+                const newNode = new HashTableNode(currentNode.key, currentNode.val);
+                if (!newBuckets[newIndex]) {
+                    newBuckets[newIndex] = newNode;
+                }
+                else {
+                    let currentNewNode = newBuckets[newIndex];
+                    while (currentNewNode.next) {
+                        currentNewNode = currentNewNode.next;
+                    }
+                    currentNewNode.next = newNode;
+                }
+                currentNode = currentNode.next;
+            }
+        }
+        this._buckets = newBuckets;
+        this._capacity = newCapacity;
+    }
+    get size() {
+        return this._size;
+    }
 }
+HashTable.DEFAULT_CAPACITY = 16;
+HashTable.LOAD_FACTOR = 0.75;

package/lib/data-structures/hash/index.d.ts

@@ -4,3 +4,4 @@ export * from './coordinate-set';
 export * from './pair';
 export * from './tree-map';
 export * from './tree-set';
+export * from './hash-map';

package/lib/data-structures/hash/index.js

@@ -4,3 +4,4 @@ export * from './coordinate-set';
 export * from './pair';
 export * from './tree-map';
 export * from './tree-set';
+export * from './hash-map';

package/lib/data-structures/linked-list/skip-linked-list.d.ts

@@ -1,2 +1,61 @@
-export declare class SkipLinkedList {
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class SkipListNode<K, V> {
+    key: K;
+    value: V;
+    forward: SkipListNode<K, V>[];
+    constructor(key: K, value: V, level: number);
+}
+export declare class SkipList<K, V> {
+    get probability(): number;
+    set probability(value: number);
+    get maxLevel(): number;
+    set maxLevel(value: number);
+    get level(): number;
+    set level(value: number);
+    get head(): SkipListNode<K, V>;
+    set head(value: SkipListNode<K, V>);
+    private _head;
+    private _level;
+    private _maxLevel;
+    private _probability;
+    /**
+     * The constructor initializes a SkipList with a specified maximum level and probability.
+     * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
+     * the maximum number of levels that can be created in the skip list.
+     * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
+     * level in the skip list. It is used to determine the height of each node in the skip list.
+     */
+    constructor(maxLevel?: number, probability?: number);
+    /**
+     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * @returns the level, which is a number.
+     */
+    private randomLevel;
+    /**
+     * The add function adds a new node with a given key and value to a Skip List data structure.
+     * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
+     * @param {V} value - The "value" parameter represents the value associated with the key that is being added to the Skip
+     * List.
+     */
+    add(key: K, value: V): void;
+    /**
+     * The function `get` retrieves the value associated with a given key from a skip list data structure.
+     * @param {K} key - The `key` parameter is the key of the element that we want to retrieve from the data structure.
+     * @returns The method `get(key: K)` returns the value associated with the given key if it exists in the data structure,
+     * otherwise it returns `undefined`.
+     */
+    get(key: K): V | undefined;
+    /**
+     * The `remove` function removes a node with a specific key from a Skip List data structure.
+     * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
+     * @returns The `remove` method returns a boolean value. It returns `true` if the key was successfully removed from the
+     * skip list, and `false` if the key was not found in the skip list.
+     */
+    remove(key: K): boolean;
 }

package/lib/data-structures/linked-list/skip-linked-list.js

@@ -1,2 +1,137 @@
-export class SkipLinkedList {
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class SkipListNode {
+    constructor(key, value, level) {
+        this.key = key;
+        this.value = value;
+        this.forward = new Array(level);
+    }
+}
+export class SkipList {
+    get probability() {
+        return this._probability;
+    }
+    set probability(value) {
+        this._probability = value;
+    }
+    get maxLevel() {
+        return this._maxLevel;
+    }
+    set maxLevel(value) {
+        this._maxLevel = value;
+    }
+    get level() {
+        return this._level;
+    }
+    set level(value) {
+        this._level = value;
+    }
+    get head() {
+        return this._head;
+    }
+    set head(value) {
+        this._head = value;
+    }
+    /**
+     * The constructor initializes a SkipList with a specified maximum level and probability.
+     * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
+     * the maximum number of levels that can be created in the skip list.
+     * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
+     * level in the skip list. It is used to determine the height of each node in the skip list.
+     */
+    constructor(maxLevel = 16, probability = 0.5) {
+        this._head = new SkipListNode(null, null, maxLevel);
+        this._level = 0;
+        this._maxLevel = maxLevel;
+        this._probability = probability;
+    }
+    /**
+     * The function "randomLevel" generates a random level based on a given probability and maximum level.
+     * @returns the level, which is a number.
+     */
+    randomLevel() {
+        let level = 1;
+        while (Math.random() < this.probability && level < this.maxLevel) {
+            level++;
+        }
+        return level;
+    }
+    /**
+     * The add function adds a new node with a given key and value to a Skip List data structure.
+     * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
+     * @param {V} value - The "value" parameter represents the value associated with the key that is being added to the Skip
+     * List.
+     */
+    add(key, value) {
+        const newNode = new SkipListNode(key, value, this.randomLevel());
+        const update = new Array(this.maxLevel).fill(this.head);
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i] && current.forward[i].key < key) {
+                current = current.forward[i];
+            }
+            update[i] = current;
+        }
+        for (let i = 0; i < newNode.forward.length; i++) {
+            newNode.forward[i] = update[i].forward[i];
+            update[i].forward[i] = newNode;
+        }
+        if (newNode.forward[0] !== null) {
+            this.level = Math.max(this.level, newNode.forward.length);
+        }
+    }
+    /**
+     * The function `get` retrieves the value associated with a given key from a skip list data structure.
+     * @param {K} key - The `key` parameter is the key of the element that we want to retrieve from the data structure.
+     * @returns The method `get(key: K)` returns the value associated with the given key if it exists in the data structure,
+     * otherwise it returns `undefined`.
+     */
+    get(key) {
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i] && current.forward[i].key < key) {
+                current = current.forward[i];
+            }
+        }
+        current = current.forward[0];
+        if (current && current.key === key) {
+            return current.value;
+        }
+        return undefined;
+    }
+    /**
+     * The `remove` function removes a node with a specific key from a Skip List data structure.
+     * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
+     * @returns The `remove` method returns a boolean value. It returns `true` if the key was successfully removed from the
+     * skip list, and `false` if the key was not found in the skip list.
+     */
+    remove(key) {
+        const update = new Array(this.maxLevel).fill(this.head);
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i] && current.forward[i].key < key) {
+                current = current.forward[i];
+            }
+            update[i] = current;
+        }
+        current = current.forward[0];
+        if (current && current.key === key) {
+            for (let i = 0; i < this.level; i++) {
+                if (update[i].forward[i] !== current) {
+                    break;
+                }
+                update[i].forward[i] = current.forward[i];
+            }
+            while (this.level > 0 && this.head.forward[this.level - 1] === null) {
+                this.level--;
+            }
+            return true;
+        }
+        return false;
+    }
 }

package/lib/types/data-structures/hash.d.ts

@@ -0,0 +1 @@
+export type HashFunction<K> = (key: K) => number;

package/lib/types/data-structures/hash.js

@@ -0,0 +1 @@
+export {};

package/lib/types/data-structures/index.d.ts

@@ -13,3 +13,4 @@ export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
 export * from './navigator';
+export * from './hash';

package/lib/types/data-structures/index.js

@@ -13,3 +13,4 @@ export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
 export * from './navigator';
+export * from './hash';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.33.6",
+  "version": "1.33.7",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",

package/src/data-structures/binary-tree/segment-tree.ts

@@ -87,12 +87,21 @@ export class SegmentTree {
    * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
    */
   constructor(values: number[], start?: number, end?: number) {
+    console.log('values.length:', values.length);
     start = start || 0;
     end = end || values.length - 1;
     this._values = values;
     this._start = start;
     this._end = end;
-    this._root = this.build(start, end);
+
+    if (values.length > 0) {
+      console.log('Initializing with non-empty array');
+      this._root = this.build(start, end);
+    } else {
+      console.log('Initializing with empty array');
+      this._root = null;
+      this._values = [];
+    }
   }
 
   private _values: number[] = [];
@@ -119,15 +128,18 @@ export class SegmentTree {
   }
 
   /**
-   * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
-   * for each segment.
+   * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
+   * the sum of values to each segment.
    * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
    * building the segment tree.
-   * @param {number} end - The `end` parameter represents the ending index of the segment or range for which we are
-   * building the segment tree.
+   * @param {number} end - The "end" parameter represents the ending index of the segment or range for which we want to
+   * build a segment tree.
    * @returns a SegmentTreeNode object.
    */
   build(start: number, end: number): SegmentTreeNode {
+    if (start > end) {
+      return new SegmentTreeNode(start, end, 0);
+    }
     if (start === end) return new SegmentTreeNode(start, end, this._values[start]);
 
     const mid = start + Math.floor((end - start) / 2);
@@ -192,33 +204,39 @@ export class SegmentTree {
       return 0;
     }
 
+    if (indexA < 0 || indexB >= this.values.length || indexA > indexB) {
+      return NaN;
+    }
+
     const dfs = (cur: SegmentTreeNode, i: number, j: number): number => {
-      if (cur.start === i && cur.end === j) {
+      if (i <= cur.start && j >= cur.end) {
+        // The range [i, j] completely covers the current node's range [cur.start, cur.end]
         return cur.sum;
       }
       const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
       if (j <= mid) {
-        // TODO after no-non-null-assertion not ensure the logic
         if (cur.left) {
           return dfs(cur.left, i, j);
         } else {
           return NaN;
         }
       } else if (i > mid) {
-        // TODO after no-non-null-assertion not ensure the logic
         if (cur.right) {
-          // TODO after no-non-null-assertion not ensure the logic
           return dfs(cur.right, i, j);
         } else {
           return NaN;
         }
       } else {
-        // TODO after no-non-null-assertion not ensure the logic
-        if (cur.left && cur.right) {
-          return dfs(cur.left, i, mid) + dfs(cur.right, mid + 1, j);
-        } else {
-          return NaN;
+        // Query both left and right subtrees
+        let leftSum = 0;
+        let rightSum = 0;
+        if (cur.left) {
+          leftSum = dfs(cur.left, i, mid);
+        }
+        if (cur.right) {
+          rightSum = dfs(cur.right, mid + 1, j);
         }
+        return leftSum + rightSum;
       }
     };
     return dfs(root, indexA, indexB);