typescript-ds-lib 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-ds-lib",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "A collection of TypeScript data structure implementations",
   "author": "Artiom Baloian <artiom.baloian@gmail.com>",
   "license": "MIT",
@@ -8,14 +8,12 @@
   "types": "dist/index.d.ts",
   "files": [
     "dist",
-    "lib",
-    "types",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "rm -rf dist && tsc",
-    "prepare": "npm run build", 
+    "prepare": "npm run build",
     "test": "rm -rf dist && tsc && jest"
   },
   "repository": {

package/lib/binary-search-tree.ts

@@ -1,218 +0,0 @@
-import { Comparator } from '../types';
-
-
-export interface BinarySearchTree<T> {
-  insert(element: T): void;
-  remove(element: T): void;
-  find(element: T): boolean;
-  min(): T | undefined;
-  max(): T | undefined;
-  forEach(callback: (element: T) => void, traversal?: 'inorder' | 'preorder' | 'postorder'): void;
-  isEmpty(): boolean;
-  clear(): void;
-  count(): number;
-}
-
-
-class TreeNode<T> {
-  value: T;
-  left: TreeNode<T> | null;
-  right: TreeNode<T> | null;
-
-  constructor(value: T) {
-    this.value = value;
-    this.left = null;
-    this.right = null;
-  }
-}
-
-
-export class BinarySearchTree<T> implements BinarySearchTree<T> {
-  private root: TreeNode<T> | null;
-  private comparator: Comparator<T>;
-
-  constructor(comparator: Comparator<T> = (a: T, b: T) => a < b) {
-    this.root = null;
-    this.comparator = comparator;
-  }
-
-  /**
-   * Inserts a value into the BST
-   */
-  insert(value: T): void {
-    const newNode = new TreeNode(value);
-    if (!this.root) {
-      this.root = newNode;
-      return;
-    }
-    let current = this.root;
-    while (true) {
-      if (this.comparator(value, current.value)) {
-        if (current.left === null) {
-          current.left = newNode;
-          break;
-        }
-        current = current.left;
-      } else {
-        if (current.right === null) {
-          current.right = newNode;
-          break;
-        }
-        current = current.right;
-      }
-    }
-  }
-
-  /**
-   * Searches for a value in the BST. Returns true if found, false otherwise
-   */
-  find(value: T): boolean {
-    let current = this.root;
-    while (current !== null) {
-      if (this.isEqual(value, current.value)) {
-        return true;
-      }
-      if (this.comparator(value, current.value)) {
-        current = current.left;
-      } else {
-        current = current.right;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Returns the minimum value in the BST, or undefined if tree is empty
-   */
-  min(): T | undefined {
-    if (!this.root) return undefined;
-    let current = this.root;
-    while (current.left !== null) {
-      current = current.left;
-    }
-    return current.value;
-  }
-
-  /**
-   * Returns the maximum value in the BST, or undefined if tree is empty
-   */
-  max(): T | undefined {
-    if (!this.root) return undefined;
-    let current = this.root;
-    while (current.right !== null) {
-      current = current.right;
-    }
-    return current.value;
-  }
-
-  /**
-   * Removes a value from the BST if it exists
-   */
-  remove(value: T): void {
-    this.root = this.removeNode(this.root, value);
-  }
-
-  private removeNode(node: TreeNode<T> | null, value: T): TreeNode<T> | null {
-    if (node === null) return null;
-    if (this.comparator(value, node.value)) {
-      node.left = this.removeNode(node.left, value);
-      return node;
-    } else if (this.comparator(node.value, value)) {
-      node.right = this.removeNode(node.right, value);
-      return node;
-    } else {
-      // Node to delete found
-      // Case 1: Leaf node
-      if (node.left === null && node.right === null) {
-        return null;
-      }
-      // Case 2: Node with one child
-      if (node.left === null) return node.right;
-      if (node.right === null) return node.left;
-      // Case 3: Node with two children
-      const minNode = this.findMin(node.right);
-      node.value = minNode.value;
-      node.right = this.removeNode(node.right, minNode.value);
-      return node;
-    }
-  }
-
-  private findMin(node: TreeNode<T>): TreeNode<T> {
-    let current = node;
-    while (current.left !== null) {
-      current = current.left;
-    }
-    return current;
-  }
-
-  private isEqual(a: T, b: T): boolean {
-    // Two values are equal if neither is less than the other
-    return !this.comparator(a, b) && !this.comparator(b, a);
-  }
-
-  /**
-   * Executes a callback function for each element in the BST in-order traversal
-   */
-  forEach(callback: (element: T) => void, traversal: 'inorder' | 'preorder' | 'postorder' = 'inorder'): void {
-    switch (traversal) {
-      case 'inorder':
-        this.inorderTraversal(this.root, callback);
-        break;
-      case 'preorder':
-        this.preorderTraversal(this.root, callback);
-        break;
-      case 'postorder':
-        this.postorderTraversal(this.root, callback);
-        break;
-      default:
-        this.inorderTraversal(this.root, callback);
-    }
-  }
-
-  private inorderTraversal(node: TreeNode<T> | null, callback: (element: T) => void): void {
-    if (node === null) return;
-    this.inorderTraversal(node.left, callback);
-    callback(node.value);
-    this.inorderTraversal(node.right, callback);
-  }
-
-  private preorderTraversal(node: TreeNode<T> | null, callback: (element: T) => void): void {
-    if (node === null) return;
-    callback(node.value);
-    this.preorderTraversal(node.left, callback);
-    this.preorderTraversal(node.right, callback);
-  }
-
-  private postorderTraversal(node: TreeNode<T> | null, callback: (element: T) => void): void {
-    if (node === null) return;
-    this.postorderTraversal(node.left, callback);
-    this.postorderTraversal(node.right, callback);
-    callback(node.value);
-  }
-
-  /**
-   * Returns true if the BST is empty, false otherwise
-   */
-  isEmpty(): boolean {
-    return this.root === null;
-  }
-
-  /**
-   * Removes all nodes from the BST
-   */
-  clear(): void {
-    this.root = null;
-  }
-
-  /**
-   * Returns the number of nodes in the BST
-   */
-  count(): number {
-    return this.countNodes(this.root);
-  }
-
-  private countNodes(node: TreeNode<T> | null): number {
-    if (node === null) return 0;
-    return 1 + this.countNodes(node.left) + this.countNodes(node.right);
-  }
-}

package/lib/deque.ts

@@ -1,86 +0,0 @@
-import { LinkedList } from './linked-list';
-
-
-export interface Deque<T> {
-  pushFront(element: T): void;
-  pushBack(element: T): void;
-  popFront(): T | undefined;
-  popBack(): T | undefined;
-  front(): T | undefined;
-  back(): T | undefined;
-  isEmpty(): boolean;
-  size(): number;
-  clear(): void;
-}
-
-
-export class Deque<T> implements Deque<T> {
-  private items: LinkedList<T>;
-
-  constructor() {
-    this.items = new LinkedList<T>();
-  }
-
-  /**
-   * Adds an element to the front of the deque
-   */
-  pushFront(element: T): void {
-    this.items.pushFront(element);
-  }
-
-  /**
-   * Adds an element to the back of the deque
-   */
-  pushBack(element: T): void {
-    this.items.pushBack(element);
-  }
-
-  /**
-   * Removes and returns the front element from the deque, or undefined if deque is empty
-   */
-  popFront(): T | undefined {
-    return this.items.popFront();
-  }
-
-  /**
-   * Removes and returns the back element from the deque, or undefined if deque is empty
-   */
-  popBack(): T | undefined {
-    return this.items.popBack();
-  }
-
-  /**
-   * Returns the front element without removing it, or undefined if deque is empty
-   */
-  front(): T | undefined {
-    return this.items.get(0);
-  }
-
-  /**
-   * Returns the back element without removing it, or undefined if deque is empty
-   */
-  back(): T | undefined {
-    return this.items.get(this.items.size() - 1);
-  }
-
-  /**
-   * Returns true if the deque is empty, false otherwise
-   */
-  isEmpty(): boolean {
-    return this.items.isEmpty();
-  }
-
-  /**
-   * Returns the number of elements in the deque
-   */
-  size(): number {
-    return this.items.size();
-  }
-
-  /**
-   * Removes all elements from the deque
-   */
-  clear(): void {
-    this.items.clear();
-  }
-}

package/lib/hash-table.ts

@@ -1,179 +0,0 @@
-export interface HashTable<K, V> {
-  insert(key: K, value: V): void;
-  get(key: K): V | undefined;
-  remove(key: K): boolean;
-  size(): number;
-  isEmpty(): boolean;
-  clear(): void;
-}
-
-
-class HashNode<K, V> {
-  key: K;
-  value: V;
-  next: HashNode<K, V> | null;
-
-  constructor(key: K, value: V) {
-    this.key = key;
-    this.value = value;
-    this.next = null;
-  }
-}
-
-export class HashTable<K, V> implements HashTable<K, V> {
-  private table: Array<HashNode<K, V> | null>;
-  private count: number;
-  private readonly capacity: number;
-
-  constructor(capacity: number = 32) {
-    this.table = new Array(capacity).fill(null);
-    this.count = 0;
-    this.capacity = capacity;
-  }
-
-  private hash(key: K): number {
-    if (typeof (key as any).hashCode === 'function') {
-      return (key as any).hashCode();
-    }
-
-    let stringKey: string;
-    switch (typeof key) {
-      case 'number':
-        // If the number is a safe integer, use Knuth's multiplicative method.
-        if (Number.isSafeInteger(key)) {
-          const knuthConstant = 2654435761;
-          return (Math.abs(key * knuthConstant) >>> 0) % this.capacity;
-        }
-        stringKey = key.toString();
-        break;
-      case 'object':
-        if (key === null) {
-          stringKey = 'null';
-        } else if (typeof (key as any).toString === 'function') {
-          stringKey = (key as any).toString();
-        } else {
-          stringKey = JSON.stringify(key);
-        }
-        break;
-      case 'string':
-        stringKey = key;
-        break;
-      case 'function':
-        stringKey = key.toString();
-        break;
-      case 'symbol':
-        stringKey = key.toString();
-        break;
-      case 'undefined':
-        stringKey = 'null';
-        break;
-      default:
-        stringKey = String(key);
-    }
-    let hash = 0;
-    // DJB2 hash algorithm
-    for (let i = 0; i < stringKey.length; i++) {
-      hash = ((hash << 5) + hash) + stringKey.charCodeAt(i);
-      hash = hash >>> 0; // Convert to 32-bit unsigned integer
-    }
-    return hash % this.capacity;
-  }
-
-  insert(key: K, value: V): void {
-    const index = this.hash(key);
-    const newNode = new HashNode(key, value);
-    if (!this.table[index]) {
-      this.table[index] = newNode;
-      this.count++;
-      return;
-    }
-    let current = this.table[index];
-    while (current) {
-      if (this.keysEqual(current.key, key)) {
-        current.value = value;
-        return;
-      }
-      if (!current.next) {
-        current.next = newNode;
-        this.count++;
-        return;
-      }
-      current = current.next;
-    }
-  }
-
-  get(key: K): V | undefined {
-    const index = this.hash(key);
-    let current = this.table[index];
-    while (current) {
-      if (this.keysEqual(current.key, key)) {
-        return current.value;
-      }
-      current = current.next;
-    }
-    return undefined;
-  }
-
-  remove(key: K): boolean {
-    const index = this.hash(key);
-    let current = this.table[index];
-    let prev: HashNode<K, V> | null = null;
-    while (current) {
-      if (this.keysEqual(current.key, key)) {
-        if (prev) {
-          prev.next = current.next;
-        } else {
-          this.table[index] = current.next;
-        }
-        this.count--;
-        return true;
-      }
-      prev = current;
-      current = current.next;
-    }
-    return false;
-  }
-
-  private keysEqual(key1: K, key2: K): boolean {
-    // Check if keys have equals method and use it for comparison
-    if (typeof (key1 as any).equals === 'function') {
-      return (key1 as any).equals(key2);
-    }
-    if (key1 === key2) return true;
-    if (key1 == null || key2 == null) return false;
-
-    if (typeof key1 !== 'object' && typeof key2 !== 'object') {
-      return key1 === key2;
-    }
-    if (key1 instanceof Date && key2 instanceof Date) {
-      return key1.getTime() === key2.getTime();
-    }
-    if (key1 instanceof RegExp && key2 instanceof RegExp) {
-      return key1.toString() === key2.toString();
-    }
-    if (Array.isArray(key1) && Array.isArray(key2)) {
-      return key1.length === key2.length &&
-        key1.every((val, idx) => this.keysEqual(val, key2[idx]));
-    }
-    if (typeof key1 === 'object' && typeof key2 === 'object') {
-      const keys1 = Object.keys(key1);
-      const keys2 = Object.keys(key2);
-      return keys1.length === keys2.length &&
-        keys1.every(k => k in key2 && this.keysEqual((key1 as any)[k], (key2 as any)[k]));
-    }
-    return false;
-  }
-
-  size(): number {
-    return this.count;
-  }
-
-  isEmpty(): boolean {
-    return this.count === 0;
-  }
-
-  clear(): void {
-    this.table = new Array(this.capacity).fill(null);
-    this.count = 0;
-  }
-}