data-structure-typed 1.48.7 → 1.48.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.48.7",
+  "version": "1.48.9",
   "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

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

@@ -98,10 +98,6 @@ export class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N>
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
- * 6. Internal Nodes: Nodes with at least one child are internal.
- * 7. Balanced Trees: The heights of the left and right subtrees of any node differ by no more than one.
- * 8. Full Trees: Every node has either 0 or 2 children.
- * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
 
 export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>> extends IterableEntryBase<K, V | undefined>
@@ -231,7 +227,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Space Complexity O(1)
    */
 
-
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
@@ -243,50 +238,65 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
    */
   add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V): N | null | undefined {
-
-    let inserted: N | null | undefined;
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
     if (newNode === undefined) return;
 
-    // TODO There are still some problems with the way duplicate nodes are handled
-    if (newNode !== null && this.has(newNode.key)) return undefined;
+    // If the tree is empty, directly set the new node as the root node
+    if (!this.root) {
+      this._root = newNode;
+      this._size = 1;
+      return newNode;
+    }
 
-    const _bfs = (root: N, newNode: N | null): N | undefined | null => {
-      const queue = new Queue<N>([root]);
-      while (queue.size > 0) {
-        const cur = queue.shift()!;
-        if (newNode && cur.key === newNode.key) {
-          this._replaceNode(cur, newNode);
-          return newNode;
-        }
-        const inserted = this._addTo(newNode, cur);
-        if (inserted !== undefined) return inserted;
-        if (cur.left) queue.push(cur.left);
-        if (cur.right) queue.push(cur.right);
+    const queue = new Queue<N>([this.root]);
+    let potentialParent: N | undefined; // Record the parent node of the potential insertion location
+
+    while (queue.size > 0) {
+      const cur = queue.shift();
+
+      if (!cur) continue;
+
+      // Check for duplicate keys when newNode is not null
+      if (newNode !== null && cur.key === newNode.key) {
+        this._replaceNode(cur, newNode);
+        return newNode; // If duplicate keys are found, no insertion is performed
       }
-    };
 
-    if (this.root) {
-      inserted = _bfs(this.root, newNode);
-    } else {
-      this._setRoot(newNode);
-      if (newNode) {
-        this._size = 1;
-      } else {
-        this._size = 0;
+      // Record the first possible insertion location found
+      if (potentialParent === undefined && (cur.left === undefined || cur.right === undefined)) {
+        potentialParent = cur;
+      }
+
+      // Continue traversing the left and right subtrees
+      if (cur.left !== null) {
+        cur.left && queue.push(cur.left);
+      }
+      if (cur.right !== null) {
+        cur.right && queue.push(cur.right);
       }
-      inserted = this.root;
     }
-    return inserted;
+
+    // At the end of the traversal, if the insertion position is found, insert
+    if (potentialParent) {
+      if (potentialParent.left === undefined) {
+        potentialParent.left = newNode;
+      } else if (potentialParent.right === undefined) {
+        potentialParent.right = newNode;
+      }
+      this._size++;
+      return newNode;
+    }
+
+    return undefined; // If the insertion position cannot be found, return undefined
   }
 
+
   /**
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
    * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
    */
 
-
   /**
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)

package/src/data-structures/queue/deque.ts

@@ -849,194 +849,4 @@ export class Deque<E> extends IterableElementBase<E> {
 
     return { bucketIndex, indexInBucket };
   }
-}
-
-// O(1) time complexity of obtaining the element
-// O(n) time complexity of adding at the beginning and the end
-// todo tested slowest one
-export class ObjectDeque<E = number> {
-  constructor(capacity?: number) {
-    if (capacity !== undefined) this._capacity = capacity;
-  }
-
-  protected _nodes: { [key: number]: E } = {};
-
-  get nodes(): { [p: number]: E } {
-    return this._nodes;
-  }
-
-  protected _capacity = Number.MAX_SAFE_INTEGER;
-
-  get capacity(): number {
-    return this._capacity;
-  }
-
-  protected _first = -1;
-
-  get first(): number {
-    return this._first;
-  }
-
-  protected _last = -1;
-
-  get last(): number {
-    return this._last;
-  }
-
-  protected _size = 0;
-
-  get size(): number {
-    return this._size;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The "addFirst" function adds an element to the beginning of an array-like data structure.
-   * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
-   * structure.
-   */
-  addFirst(element: E) {
-    if (this.size === 0) {
-      const mid = Math.floor(this.capacity / 2);
-      this._first = mid;
-      this._last = mid;
-    } else {
-      this._first--;
-    }
-    this.nodes[this.first] = element;
-    this._size++;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The addLast function adds an element to the end of an array-like data structure.
-   * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
-   */
-  addLast(element: E) {
-    if (this.size === 0) {
-      const mid = Math.floor(this.capacity / 2);
-      this._first = mid;
-      this._last = mid;
-    } else {
-      this._last++;
-    }
-    this.nodes[this.last] = element;
-    this._size++;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `pollFirst()` removes and returns the first element in a data structure.
-   * @returns The element of the first element in the data structure.
-   */
-  pollFirst() {
-    if (!this.size) return;
-    const element = this.getFirst();
-    delete this.nodes[this.first];
-    this._first++;
-    this._size--;
-    return element;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `getFirst` function returns the first element in an array-like data structure if it exists.
-   * @returns The element at the first position of the `_nodes` array.
-   */
-  getFirst() {
-    if (this.size) return this.nodes[this.first];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `pollLast()` function removes and returns the last element in a data structure.
-   * @returns The element that was removed from the data structure.
-   */
-  pollLast() {
-    if (!this.size) return;
-    const element = this.getLast();
-    delete this.nodes[this.last];
-    this._last--;
-    this._size--;
-
-    return element;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `getLast()` function returns the last element in an array-like data structure.
-   * @returns The last element in the array "_nodes" is being returned.
-   */
-  getLast() {
-    if (this.size) return this.nodes[this.last];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The get function returns the element at the specified index in an array-like data structure.
-   * @param {number} index - The index parameter is a number that represents the position of the element you want to
-   * retrieve from the array.
-   * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-   * index, `undefined` is returned.
-   */
-  get(index: number) {
-    return this.nodes[this.first + index] || undefined;
-  }
-
-  /**
-   * The function checks if the size of a data structure is less than or equal to zero.
-   * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
-   */
-  isEmpty() {
-    return this.size <= 0;
-  }
-}
+}

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

@@ -1,8 +1,8 @@
 import { BinaryTree, BinaryTreeNode, FamilyPosition, IterationType } from '../../../../src';
 import { getRandomIntArray } from '../../../utils';
-// import {isDebugTest} from '../../../config';
+import { isDebugTest } from '../../../config';
 
-// const isDebug = isDebugTest;
+const isDebug = isDebugTest;
 
 describe('BinaryTreeNode', () => {
   it('should create an instance of BinaryTreeNode', () => {
@@ -106,7 +106,7 @@ describe('BinaryTree', () => {
   it('should delete nodes', () => {
     expect(tree.getHeight(tree.root, IterationType.ITERATIVE)).toBe(-1);
     expect(tree.getMinHeight()).toBe(-1);
-    const node = tree.add(1);
+    const node1 = tree.add(1);
     expect(tree.size).toBe(1);
 
     const leftChild = new BinaryTreeNode<number>(2);
@@ -127,10 +127,10 @@ describe('BinaryTree', () => {
     tree.delete(new BinaryTreeNode<number>(200));
     tree.delete(rightChild);
 
-    if (node) {
-      const result = tree.delete(node);
+    if (node1) {
+      const result = tree.delete(node1);
       expect(result).toHaveLength(1);
-      expect(tree.size).toBe(3);
+      expect(tree.size).toBe(4);
       expect(tree.getMinHeight(tree.root, IterationType.RECURSIVE)).toBe(1);
     }
   });
@@ -260,11 +260,18 @@ describe('BinaryTree', () => {
     expect(tree.size).toBe(0);
     expect(tree.root).toBeUndefined();
   });
+
+  it('should duplicated nodes just replace the node exists', function () {
+    tree.clear();
+    tree.addMany([-10, -10, -10, 9, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null, 8, 8, 8]);
+
+    expect(tree.bfs(node => node ? node.key : null, undefined, undefined, true)).toEqual([-10, 9, 20, null, null, 15, 7, 8, null, 2, null, 6, null, null])
+  });
 });
 
 describe('BinaryTree Morris Traversal', () => {
   // Create a binary tree
-  const tree = new BinaryTree<number, BinaryTreeNode<number>>();
+  const tree = new BinaryTree<number>();
   tree.add(1);
   tree.add(2);
   tree.add(3);
@@ -448,7 +455,7 @@ describe('BinaryTree', () => {
 
   it('should get the height of the tree', () => {
     tree.add([5, 'A']);
-    tree.add([3, 'B']);
+    tree.add(3, 'B');
     tree.add([7, 'C']);
 
     expect(tree.getHeight()).toBe(1);

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

@@ -5,7 +5,7 @@ const isDebug = isDebugTest;
 
 describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST();
+    const bst = new BST<number, number>();
     expect(bst).toBeInstanceOf(BST);
     bst.add([11, 11]);
     bst.add([3, 3]);

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

@@ -6,10 +6,10 @@ import { OrderedMap } from 'js-sdsl';
 const isDebug = isDebugTest;
 
 describe('RedBlackTree', () => {
-  let tree: RedBlackTree;
+  let tree: RedBlackTree<number>;
 
   beforeEach(() => {
-    tree = new RedBlackTree();
+    tree = new RedBlackTree<number>();
   });
 
   describe('add and getNode', () => {
@@ -141,10 +141,10 @@ describe('RedBlackTree', () => {
 });
 
 describe('RedBlackTree', () => {
-  let tree: RedBlackTree;
+  let tree: RedBlackTree<number>;
 
   beforeEach(() => {
-    tree = new RedBlackTree();
+    tree = new RedBlackTree<number>();
   });
 
   it('should add nodes into the tree', () => {
@@ -511,7 +511,7 @@ describe('RedBlackTree iterative methods test', () => {
   beforeEach(() => {
     rbTree = new RedBlackTree();
     rbTree.add([1, 'a']);
-    rbTree.add([2, 'b']);
+    rbTree.add(2, 'b');
     rbTree.add([3, 'c']);
   });