data-structure-typed 1.39.6 → 1.40.0

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

@@ -4,8 +4,6 @@
  * @class
  */
 export class Stack<E = any> {
-  protected _elements: E[];
-
   /**
    * The constructor initializes an array of elements, which can be provided as an optional parameter.
    * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
@@ -16,6 +14,12 @@ export class Stack<E = any> {
     this._elements = Array.isArray(elements) ? elements : [];
   }
 
+  protected _elements: E[];
+
+  get elements(): E[] {
+    return this._elements;
+  }
+
   /**
    * The function "fromArray" creates a new Stack object from an array of elements.
    * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -31,7 +35,7 @@ export class Stack<E = any> {
    * @returns A boolean value indicating whether the `_elements` array is empty or not.
    */
   isEmpty(): boolean {
-    return this._elements.length === 0;
+    return this.elements.length === 0;
   }
 
   /**
@@ -39,7 +43,7 @@ export class Stack<E = any> {
    * @returns The size of the elements array.
    */
   size(): number {
-    return this._elements.length;
+    return this.elements.length;
   }
 
   /**
@@ -49,7 +53,7 @@ export class Stack<E = any> {
   peek(): E | null {
     if (this.isEmpty()) return null;
 
-    return this._elements[this._elements.length - 1];
+    return this.elements[this.elements.length - 1];
   }
 
   /**
@@ -58,7 +62,7 @@ export class Stack<E = any> {
    * @returns The `push` method is returning the updated `Stack<E>` object.
    */
   push(element: E): Stack<E> {
-    this._elements.push(element);
+    this.elements.push(element);
     return this;
   }
 
@@ -70,7 +74,7 @@ export class Stack<E = any> {
   pop(): E | null {
     if (this.isEmpty()) return null;
 
-    return this._elements.pop() || null;
+    return this.elements.pop() || null;
   }
 
   /**
@@ -78,7 +82,7 @@ export class Stack<E = any> {
    * @returns An array of type E.
    */
   toArray(): E[] {
-    return this._elements.slice();
+    return this.elements.slice();
   }
 
   /**
@@ -93,6 +97,6 @@ export class Stack<E = any> {
    * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
    */
   clone(): Stack<E> {
-    return new Stack(this._elements.slice());
+    return new Stack(this.elements.slice());
   }
 }

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

@@ -1,38 +1,12 @@
 export class TreeNode<V = any> {
-  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
-    this._key = key;
-    this._value = value || undefined;
-    this._children = children || [];
-  }
-
-  private _key: string;
-
-  get key(): string {
-    return this._key;
-  }
-
-  set key(value: string) {
-    this._key = value;
-  }
-
-  private _value?: V | undefined;
+  key: string;
+  value?: V | undefined;
+  children?: TreeNode<V>[] | undefined;
 
-  get value(): V | undefined {
-    return this._value;
-  }
-
-  set value(value: V | undefined) {
-    this._value = value;
-  }
-
-  private _children?: TreeNode<V>[] | undefined;
-
-  get children(): TreeNode<V>[] | undefined {
-    return this._children;
-  }
-
-  set children(value: TreeNode<V>[] | undefined) {
-    this._children = value;
+  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
+    this.key = key;
+    this.value = value || undefined;
+    this.children = children || [];
   }
 
   addChildren(children: TreeNode<V> | TreeNode<V>[]) {

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

@@ -11,40 +11,14 @@
  * and a flag indicating whether it's the end of a word.
  */
 export class TrieNode {
-  constructor(key: string) {
-    this._key = key;
-    this._isEnd = false;
-    this._children = new Map<string, TrieNode>();
-  }
-
-  private _key;
-
-  get key(): string {
-    return this._key;
-  }
-
-  set key(v: string) {
-    this._key = v;
-  }
-
-  protected _children: Map<string, TrieNode>;
-
-  get children(): Map<string, TrieNode> {
-    return this._children;
-  }
-
-  set children(v: Map<string, TrieNode>) {
-    this._children = v;
-  }
-
-  protected _isEnd: boolean;
-
-  get isEnd(): boolean {
-    return this._isEnd;
-  }
+  key: string;
+  children: Map<string, TrieNode>;
+  isEnd: boolean;
 
-  set isEnd(v: boolean) {
-    this._isEnd = v;
+  constructor(key: string) {
+    this.key = key;
+    this.isEnd = false;
+    this.children = new Map<string, TrieNode>();
   }
 }
 
@@ -52,8 +26,6 @@ export class TrieNode {
  * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
  */
 export class Trie {
-  private readonly _caseSensitive: boolean;
-
   constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
     this._caseSensitive = caseSensitive;
@@ -64,16 +36,18 @@ export class Trie {
     }
   }
 
+  protected _caseSensitive: boolean;
+
+  get caseSensitive(): boolean {
+    return this._caseSensitive;
+  }
+
   protected _root: TrieNode;
 
   get root() {
     return this._root;
   }
 
-  set root(v: TrieNode) {
-    this._root = v;
-  }
-
   /**
    * Add a word to the Trie structure.
    * @param {string} word - The word to add.
@@ -277,7 +251,7 @@ export class Trie {
     return words;
   }
 
-  private _caseProcess(str: string) {
+  protected _caseProcess(str: string) {
     if (!this._caseSensitive) {
       str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
     }

package/src/interfaces/binary-tree.ts

@@ -1,5 +1,5 @@
 import {BinaryTreeNode} from '../data-structures';
-import {BinaryTreeDeletedResult, BTNKey, BinaryTreeNodeNested, BTNCallback} from '../types';
+import {BinaryTreeDeletedResult, BinaryTreeNodeNested, BTNCallback, BTNKey} from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
   createNode(key: BTNKey, value?: N['value']): N;

package/src/types/data-structures/binary-tree/bst.ts

@@ -1,5 +1,5 @@
 import {BSTNode} from '../../../data-structures';
-import type {BTNKey, BinaryTreeOptions} from './binary-tree';
+import type {BinaryTreeOptions, BTNKey} from './binary-tree';
 
 export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
 

package/src/types/data-structures/matrix/navigator.ts

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = {[key in Direction]: Direction};
+export type Turning = { [key in Direction]: Direction };
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = {[key: string]: any};
+export type KeyValueObject = { [key: string]: any };
 
-export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 

package/test/integration/avl-tree.test.ts

@@ -31,7 +31,7 @@ describe('AVL Tree Test', () => {
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
-    expect(node15?.val).toBe(15);
+    expect(node15?.value).toBe(15);
 
     const dfs = tree.dfs(node => node, 'in');
     expect(dfs[0].key).toBe(1);

package/test/integration/bst.test.ts

@@ -23,7 +23,7 @@ describe('Individual package BST operations test', () => {
     const nodeId10 = bst.get(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.get(9, node => node.val);
+    const nodeVal9 = bst.get(9, node => node.value);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
@@ -230,7 +230,7 @@ describe('Individual package BST operations test', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.get(15);
-    expect(node15?.val).toEqual({key: 15, keyA: 15});
+    expect(node15?.value).toEqual({key: 15, keyA: 15});
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 

package/test/unit/data-structures/binary-tree/binary-index-tree.test.ts

@@ -286,8 +286,8 @@ function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
 
 describe('', () => {
   class NumArrayDC {
-    private _tree: BinaryIndexedTree;
-    private readonly _nums: number[];
+    protected _tree: BinaryIndexedTree;
+    protected readonly _nums: number[];
 
     constructor(nums: number[]) {
       this._nums = nums;

package/test/unit/data-structures/graph/abstract-graph.test.ts

@@ -19,7 +19,6 @@ class MyEdge<E = any> extends AbstractEdge<E> {
     this.src = srcOrV1;
     this.dest = destOrV2;
     this.data = value;
-    this._setHashCode('');
   }
 }
 
@@ -54,12 +53,12 @@ class MyGraph<
   }
 
   edgesOf(vertexOrKey: VO | VertexKey): EO[] {
-    const a = typeof vertexOrKey === "string" ? vertexOrKey : "a";
+    const a = typeof vertexOrKey === 'string' ? vertexOrKey : 'a';
     return [new MyEdge(a, 'b') as EO];
   }
 
   getNeighbors(vertexOrKey: VO | VertexKey): VO[] {
-    const a = typeof vertexOrKey === "string" ? vertexOrKey : "a";
+    const a = typeof vertexOrKey === 'string' ? vertexOrKey : 'a';
     return [new MyVertex(a, 'b') as VO];
   }
 
@@ -75,8 +74,7 @@ class MyGraph<
 describe('AbstractGraph Operation Test', () => {
   const myGraph: MyGraph<number, string> = new MyGraph<number, string>();
 
-  beforeEach(() => {
-  });
+  beforeEach(() => {});
   it('should edge cases', function () {
     myGraph.addVertex('A', 1);
     myGraph.addVertex('B', 2);
@@ -97,6 +95,6 @@ describe('AbstractGraph Operation Test', () => {
     eAB!.value = eAB.value;
     const hs = eAB.hashCode;
 
-    expect(hs).toBe('');
+    expect(hs.length).toBe(36);
   });
 });

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -98,7 +98,7 @@ class MyVertex<V = any> extends DirectedVertex<V> {
     this._data = value;
   }
 
-  private _data: V | undefined;
+  protected _data: V | undefined;
 
   get data(): V | undefined {
     return this._data;
@@ -115,7 +115,7 @@ class MyEdge<E = any> extends DirectedEdge<E> {
     this._data = value;
   }
 
-  private _data: E | undefined;
+  protected _data: E | undefined;
 
   get data(): E | undefined {
     return this._data;
@@ -141,11 +141,11 @@ class MyDirectedGraph<
   }
 
   setInEdgeMap(value: Map<VO, EO[]>) {
-    super._setInEdgeMap(value);
+    this._inEdgeMap = value;
   }
 
   setOutEdgeMap(value: Map<VO, EO[]>) {
-    super._setOutEdgeMap(value);
+    this._outEdgeMap = value;
   }
 }
 

package/test/unit/data-structures/graph/map-graph.test.ts

@@ -88,8 +88,8 @@ describe('MapGraph', () => {
     const edgeAB = new MapEdge('A', 'B', 50, 'Edge from A to B');
     const edgeBC = new MapEdge('B', 'C', 60, 'Edge from B to C');
 
-    mapGraph.origin = mapGraph.origin;
-    mapGraph.bottomRight = mapGraph.bottomRight;
+    expect(mapGraph.origin).toEqual([0, 0]);
+    expect(mapGraph.bottomRight).toEqual([100, 100]);
 
     mapGraph.addVertex(locationA);
     mapGraph.addVertex(locationB);

package/test/unit/data-structures/hash/coordinate-map.test.ts

@@ -57,7 +57,7 @@ describe('CoordinateMap', () => {
   class MyCoordinateMap<V = any> extends CoordinateMap<V> {
     constructor(joint?: string) {
       super(joint);
-      this._setJoint((joint += '-'));
+      this._joint = joint += '-';
     }
   }
 

package/test/unit/data-structures/hash/coordinate-set.test.ts

@@ -44,7 +44,7 @@ describe('MyCoordinateSet', () => {
   class MyCoordinateSet extends CoordinateSet {
     constructor(joint?: string) {
       super(joint);
-      this._setJoint((joint += '-'));
+      this._joint = joint += '-';
     }
   }
 

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

@@ -28,7 +28,6 @@ describe('HashMap', () => {
 
   it('should handle key collisions', () => {
     // Force a collision by setting two different keys to the same bucket
-    hashMap.hashFn = () => 0; // Override hash function to return the same index
     hashMap.set('key1', 1);
     hashMap.set('key2', 2);
 

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

@@ -15,9 +15,9 @@ describe('HashNode', () => {
 describe('HashTable', () => {
   it('should initialize with default capacity', () => {
     const hashTable = new HashTable<string, string>();
-    hashTable.capacity = hashTable.capacity;
-    hashTable.buckets = hashTable.buckets;
-    hashTable.hashFn = hashTable.hashFn;
+    expect(hashTable.capacity).toBe(16);
+    expect(hashTable.buckets).toEqual(new Array(16).fill(null));
+    expect(hashTable.hashFn('a')).toBe(6);
     expect(hashTable.capacity).toBe(16);
     expect(hashTable.size).toBe(0);
     expect(hashTable.buckets.length).toBe(16);

package/test/unit/data-structures/linked-list/skip-list.test.ts

@@ -53,3 +53,34 @@ describe('SkipList', () => {
     expect(skipList.get(4)).toBe('Four');
   });
 });
+
+describe('SkipList', () => {
+  let skipList: SkipList<number, string>;
+
+  beforeEach(() => {
+    skipList = new SkipList();
+    skipList.add(1, 'One');
+    skipList.add(2, 'Two');
+    skipList.add(3, 'Three');
+    skipList.add(4, 'Four');
+  });
+
+  test('getFirst() should return the getFirst element', () => {
+    expect(skipList.getFirst()).toBe('One');
+  });
+
+  test('getLast() should return the getLast element', () => {
+    expect(skipList.getLast()).toBe('Four');
+  });
+
+  test('higher(key) should return the getFirst element greater than the given key', () => {
+    expect(skipList.higher(2)).toBe('Three');
+    expect(skipList.higher(3)).toBe('Four');
+    expect(skipList.higher(4)).toBeUndefined();
+  });
+
+  test('lower(key) should return the getLast element less than the given key', () => {
+    expect(skipList.lower(2)).toBe('One');
+    expect(skipList.lower(1)).toBe(null);
+  });
+});

package/test/unit/data-structures/queue/queue.test.ts

@@ -1,4 +1,4 @@
-import {SkipQueue, Queue} from '../../../../src';
+import {LinkedListQueue, Queue} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 import {isDebugTest} from '../../../config';
 
@@ -168,11 +168,11 @@ describe('Queue', () => {
     expect(values).toEqual([1, 2, 3]);
   });
 });
-describe('SkipQueue', () => {
-  let queue: SkipQueue<string>;
+describe('LinkedListQueue', () => {
+  let queue: LinkedListQueue<string>;
 
   beforeEach(() => {
-    queue = new SkipQueue<string>();
+    queue = new LinkedListQueue<string>();
   });
 
   it('should enqueue elements to the end of the queue', () => {
@@ -197,7 +197,7 @@ describe('SkipQueue', () => {
     expect(queue.peek()).toBe('A');
   });
 
-  // Add more test cases for other methods of SkipQueue.
+  // Add more test cases for other methods of LinkedListQueue.
 });
 
 describe('Queue Performance Test', () => {
@@ -228,16 +228,16 @@ describe('Queue Performance Test', () => {
     expect(performance.now() - startTime2).toBeLessThan(bigO.CUBED * 100);
   });
 
-  it('should numeric SkipQueue be efficient', function () {
+  it('should numeric LinkedListQueue be efficient', function () {
     const startTime = performance.now();
-    const queue = new SkipQueue<number>();
+    const queue = new LinkedListQueue<number>();
     for (let i = 0; i < dataSize; i++) {
       queue.enqueue(i);
     }
     for (let i = 0; i < dataSize; i++) {
       queue.dequeue();
     }
-    console.log(`SkipQueue Performance Test: ${performance.now() - startTime} ms`);
+    console.log(`LinkedListQueue Performance Test: ${performance.now() - startTime} ms`);
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
   });
 });