typescript-ds-lib 0.2.7 → 0.2.9

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;
-  }
-}

package/lib/linked-list.ts

@@ -1,314 +0,0 @@
-export interface LinkedList<T> {
-  pushBack(element: T): void;
-  pushFront(element: T): void;
-  popBack(): T | undefined;
-  popFront(): T | undefined;
-  front(): T | undefined;
-  back(): T | undefined;
-  insert(element: T, position: number): boolean;
-  insertBefore(element: T, condition: (element: T) => boolean): boolean;
-  insertAfter(element: T, condition: (element: T) => boolean): boolean;
-  removeIf(condition: (element: T) => boolean): boolean;
-  removeAt(position: number): T | undefined;
-  forEach(callback: (element: T) => void): void;
-  get(position: number): T | undefined;
-  isEmpty(): boolean;
-  size(): number;
-  clear(): void;
-}
-
-
-class Node<T> {
-  value: T;
-  next: Node<T> | null;
-
-  constructor(value: T) {
-    this.value = value;
-    this.next = null;
-  }
-}
-
-
-export class LinkedList<T> implements LinkedList<T> {
-  private head: Node<T> | null;
-  private tail: Node<T> | null;
-  private length: number;
-
-  constructor() {
-    this.head = null;
-    this.tail = null;
-    this.length = 0;
-  }
-
-  /**
-   * Returns the first element in the list without removing it, or undefined if list is empty
-   */
-  front(): T | undefined {
-    return this.head?.value;
-  }
-
-  /**
-   * Returns the last element in the list without removing it, or undefined if list is empty
-   */
-  back(): T | undefined {
-    return this.tail?.value;
-  }
-
-  /**
-   * Adds an element to the end of the list
-   */
-  pushBack(element: T): void {
-    const newNode = new Node(element);
-    if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
-    } else {
-      this.tail!.next = newNode;
-      this.tail = newNode;
-    }
-    this.length++;
-  }
-
-  /**
-   * Adds an element to the front of the list
-   */
-  pushFront(element: T): void {
-    const newNode = new Node(element);
-    if (!this.head) {
-      this.head = newNode;
-      this.tail = newNode;
-    } else {
-      newNode.next = this.head;
-      this.head = newNode;
-    }
-    this.length++;
-  }
-
-  /**
-   * Removes and returns the last element from the list, or undefined if list is empty
-   */
-  popBack(): T | undefined {
-    if (!this.head) {
-      return undefined;
-    }
-    if (this.length === 1) {
-      const value = this.head.value;
-      this.head = null;
-      this.tail = null;
-      this.length = 0;
-      return value;
-    }
-    let current = this.head;
-    while (current.next !== this.tail) {
-      current = current.next!;
-    }
-    const value = this.tail!.value;
-    current.next = null;
-    this.tail = current;
-    this.length--;
-    return value;
-  }
-
-  /**
-   * Removes and returns the first element from the list, or undefined if list is empty
-   */
-  popFront(): T | undefined {
-    if (!this.head) {
-      return undefined;
-    }
-    const value = this.head.value;
-    this.head = this.head.next;
-    this.length--;
-    if (this.length === 0) {
-      this.tail = null;
-    }
-    return value;
-  }
-
-  /**
-   * Inserts an element at the specified position. Returns true if successful, false if position is invalid
-   */
-  insert(element: T, position: number): boolean {
-    if (position < 0 || position > this.length) {
-      return false;
-    }
-    if (position === 0) {
-      this.pushFront(element);
-      return true;
-    }
-    if (position === this.length) {
-      this.pushBack(element);
-      return true;
-    }
-    const newNode = new Node(element);
-    let current = this.head;
-    let prev: Node<T> | null = null;
-    let index: number = 0;
-    while (index < position) {
-      prev = current;
-      current = current!.next;
-      index++;
-    }
-    prev!.next = newNode;
-    newNode.next = current;
-    this.length++;
-    return true;
-  }
-
-  /**
-   * Inserts an element before the first element that satisfies the condition. Returns true if successful, false if no matching element found
-   */
-  insertBefore(element: T, condition: (element: T) => boolean): boolean {
-    if (!this.head) {
-      return false;
-    }
-    if (condition(this.head.value)) {
-      this.pushFront(element);
-      return true;
-    }
-    let current = this.head;
-    while (current.next !== null) {
-      if (condition(current.next.value)) {
-        const newNode = new Node(element);
-        newNode.next = current.next;
-        current.next = newNode;
-        this.length++;
-        return true;
-      }
-      current = current.next;
-    }
-    return false;
-  }
-
-  /**
-   * Inserts an element after the first element that satisfies the condition. Returns true if successful, false if no matching element found
-   */
-  insertAfter(element: T, condition: (element: T) => boolean): boolean {
-    let current = this.head;
-    while (current !== null) {
-      if (condition(current.value)) {
-        const newNode = new Node(element);
-        newNode.next = current.next;
-        current.next = newNode;
-        if (current === this.tail) {
-          this.tail = newNode;
-        }
-        this.length++;
-        return true;
-      }
-      current = current.next;
-    }
-    return false;
-  }
-
-  /**
-   * Removes the first element that satisfies the predicate. Returns true if an element was removed, false otherwise.
-   */
-  removeIf(condition: (element: T) => boolean): boolean {
-    let current: Node<T> | null = this.head;
-    let prev: Node<T> | null = null;
-    while (current !== null) {
-      if (condition(current.value)) {
-        if (prev === null) {
-          this.head = current.next;
-        } else {
-          prev.next = current.next;
-        }
-        if (current === this.tail) {
-          this.tail = prev;
-        }
-        this.length--;
-        return true;
-      }
-      prev = current;
-      current = current.next;
-    }
-    return false;
-  }
-
-  /**
-   * Removes and returns the element at the specified position. Returns undefined if position is invalid
-   */
-  removeAt(position: number): T | undefined {
-    if (position < 0 || position >= this.length) {
-      return undefined;
-    }
-    let current: Node<T> | null = this.head;
-    if (position === 0) {
-      this.head = current!.next;
-      if (this.length === 1) {
-        this.tail = null;
-      }
-      this.length--;
-      return current!.value;
-    }
-
-    let prev: Node<T> | null = null;
-    let index: number = 0;
-    while (index < position) {
-      prev = current;
-      current = current!.next;
-      index++;
-    }
-    prev!.next = current!.next;
-    if (position === this.length - 1) {
-      this.tail = prev;
-    }
-    this.length--;
-    return current!.value;
-  }
-
-  /**
-   * Executes a provided function once for each element in the list
-   */
-  forEach(callback: (element: T) => void): void {
-    let current = this.head;
-    while (current !== null) {
-      callback(current.value);
-      current = current.next;
-    }
-  }
-
-  /**
-   * Returns the element at the specified position without removing it. Returns undefined if position is invalid
-   */
-  get(position: number): T | undefined {
-    if (position < 0 || position >= this.length) {
-      return undefined;
-    }
-    // Optimize for front element
-    if (position === 0) return this.head!.value;
-    // Optimize for back element
-    if (position === this.length - 1) return this.tail!.value;
-    let current: Node<T> | null = this.head;
-    let index: number = 0;
-    while (index < position) {
-      current = current!.next;
-      index++;
-    }
-    return current!.value;
-  }
-
-  /**
-   * Returns true if the list is empty, false otherwise
-   */
-  isEmpty(): boolean {
-    return this.length === 0;
-  }
-
-  /**
-   * Returns the number of elements in the list
-   */
-  size(): number {
-    return this.length;
-  }
-
-  /**
-   * Removes all elements from the list
-   */
-  clear(): void {
-    this.head = null;
-    this.tail = null;
-    this.length = 0;
-  }
-}

package/lib/map.ts

@@ -1,55 +0,0 @@
-import { Comparator } from '../types';
-import { RedBlackTree } from './red-black-tree';
-
-
-export interface Map<K, V> {
-  insert(key: K, value: V): void;
-  find(key: K): V | undefined;
-  delete(key: K): void;
-  remove(key: K): void;
-  forEach(callback: (key: K, value: V) => void): void;
-  clear(): void;
-  isEmpty(): boolean;
-  size(): number;
-}
-
-
-export class Map<K, V> implements Map<K, V> {
-  private rbTree: RedBlackTree<K, V>;
-
-  constructor(comparator: Comparator<K> = (a: K, b: K) => a < b) {
-    this.rbTree = new RedBlackTree<K, V>(comparator);
-  }
-
-  insert(key: K, value: V): void {
-    this.rbTree.insert(key, value);
-  }
-
-  find(key: K): V | undefined {
-    return this.rbTree.find(key);
-  }
-
-  delete(key: K): void {
-    this.rbTree.remove(key);
-  }
-
-  remove(key: K): void {
-    this.rbTree.remove(key);
-  }
-
-  clear(): void {
-    this.rbTree.clear();
-  }
-
-  size(): number {
-    return this.rbTree.size();
-  }
-
-  isEmpty(): boolean {
-    return this.rbTree.isEmpty();
-  }
-
-  forEach(callback: (key: K, value: V) => void): void {
-    this.rbTree.forEach(callback);
-  }
-}