data-structure-typed 1.41.0 → 1.41.2

package/dist/mjs/data-structures/binary-tree/rb-tree.js

@@ -1,36 +1,45 @@
 "use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.RBTreeNode = void 0;
+exports.RedBlackTree = exports.NIL = exports.RBTreeNode = void 0;
 const types_1 = require("../../types");
 class RBTreeNode {
-    key = 0;
+    key;
     parent;
     left;
     right;
     color = types_1.RBTNColor.BLACK;
-    constructor() {
+    constructor(key, color = types_1.RBTNColor.BLACK) {
+        this.key = key;
+        this.color = color;
         this.parent = null;
         this.left = null;
         this.right = null;
     }
 }
 exports.RBTreeNode = RBTreeNode;
+exports.NIL = new RBTreeNode(0);
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 class RedBlackTree {
     constructor() {
-        this._NIL = new RBTreeNode();
-        this.NIL.color = types_1.RBTNColor.BLACK;
-        this.NIL.left = null;
-        this.NIL.right = null;
-        this._root = this.NIL;
+        this._root = exports.NIL;
     }
     _root;
     get root() {
         return this._root;
     }
-    _NIL;
-    get NIL() {
-        return this._NIL;
-    }
     /**
      * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
      * violations of the red-black tree properties.
@@ -39,15 +48,12 @@ class RedBlackTree {
      * @returns The function does not explicitly return anything.
      */
     insert(key) {
-        const node = new RBTreeNode();
-        node.parent = null;
-        node.key = key;
-        node.left = this.NIL;
-        node.right = this.NIL;
-        node.color = types_1.RBTNColor.RED;
+        const node = new RBTreeNode(key, types_1.RBTNColor.RED);
+        node.left = exports.NIL;
+        node.right = exports.NIL;
         let y = null;
         let x = this.root;
-        while (x !== this.NIL) {
+        while (x !== exports.NIL) {
             y = x;
             if (node.key < x.key) {
                 x = x.left;
@@ -84,9 +90,9 @@ class RedBlackTree {
      */
     delete(key) {
         const helper = (node) => {
-            let z = this.NIL;
+            let z = exports.NIL;
             let x, y;
-            while (node !== this.NIL) {
+            while (node !== exports.NIL) {
                 if (node.key === key) {
                     z = node;
                 }
@@ -97,17 +103,16 @@ class RedBlackTree {
                     node = node.left;
                 }
             }
-            if (z === this.NIL) {
-                console.log("Couldn't find key in the tree");
+            if (z === exports.NIL) {
                 return;
             }
             y = z;
             let yOriginalColor = y.color;
-            if (z.left === this.NIL) {
+            if (z.left === exports.NIL) {
                 x = z.right;
                 this._rbTransplant(z, z.right);
             }
-            else if (z.right === this.NIL) {
+            else if (z.right === exports.NIL) {
                 x = z.left;
                 this._rbTransplant(z, z.left);
             }
@@ -128,12 +133,15 @@ class RedBlackTree {
                 y.left.parent = y;
                 y.color = z.color;
             }
-            if (yOriginalColor === 0) {
+            if (yOriginalColor === types_1.RBTNColor.BLACK) {
                 this._fixDelete(x);
             }
         };
         helper(this.root);
     }
+    isRealNode(node) {
+        return node !== exports.NIL && node !== null;
+    }
     /**
      * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
      * given key in a red-black tree.
@@ -146,13 +154,17 @@ class RedBlackTree {
      */
     getNode(key, beginRoot = this.root) {
         const dfs = (node) => {
-            if (node === this.NIL || key === node.key) {
-                return node;
+            if (this.isRealNode(node)) {
+                if (key === node.key) {
+                    return node;
+                }
+                if (key < node.key)
+                    return dfs(node.left);
+                return dfs(node.right);
             }
-            if (key < node.key) {
-                return dfs(node.left);
+            else {
+                return null;
             }
-            return dfs(node.right);
         };
         return dfs(beginRoot);
     }
@@ -162,8 +174,8 @@ class RedBlackTree {
      * a Red-Black Tree.
      * @returns The leftmost node in the given RBTreeNode.
      */
-    getLeftMost(node) {
-        while (node.left !== null && node.left !== this.NIL) {
+    getLeftMost(node = this.root) {
+        while (node.left !== null && node.left !== exports.NIL) {
             node = node.left;
         }
         return node;
@@ -174,7 +186,7 @@ class RedBlackTree {
      * @returns the rightmost node in a red-black tree.
      */
     getRightMost(node) {
-        while (node.right !== null && node.right !== this.NIL) {
+        while (node.right !== null && node.right !== exports.NIL) {
             node = node.right;
         }
         return node;
@@ -185,11 +197,11 @@ class RedBlackTree {
      * @returns the successor of the given RBTreeNode.
      */
     getSuccessor(x) {
-        if (x.right !== this.NIL) {
+        if (x.right !== exports.NIL) {
             return this.getLeftMost(x.right);
         }
         let y = x.parent;
-        while (y !== this.NIL && y !== null && x === y.right) {
+        while (y !== exports.NIL && y !== null && x === y.right) {
             x = y;
             y = y.parent;
         }
@@ -202,16 +214,69 @@ class RedBlackTree {
      * @returns the predecessor of the given RBTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.NIL) {
+        if (x.left !== exports.NIL) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.NIL && x === y.left) {
+        while (y !== exports.NIL && x === y.left) {
             x = y;
             y = y.parent;
         }
         return y;
     }
+    print(beginRoot = this.root) {
+        const display = (root) => {
+            const [lines, , ,] = _displayAux(root);
+            for (const line of lines) {
+                console.log(line);
+            }
+        };
+        const _displayAux = (node) => {
+            if (node === null) {
+                return [[], 0, 0, 0];
+            }
+            if (node.right === null && node.left === null) {
+                const line = `${node.key}`;
+                const width = line.length;
+                const height = 1;
+                const middle = Math.floor(width / 2);
+                return [[line], width, height, middle];
+            }
+            if (node.right === null) {
+                const [lines, n, p, x] = _displayAux(node.left);
+                const s = `${node.key}`;
+                const u = s.length;
+                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+                const shifted_lines = lines.map(line => line + ' '.repeat(u));
+                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+            }
+            if (node.left === null) {
+                const [lines, n, p, u] = _displayAux(node.right);
+                const s = `${node.key}`;
+                const x = s.length;
+                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+            }
+            const [left, n, p, x] = _displayAux(node.left);
+            const [right, m, q, y] = _displayAux(node.right);
+            const s = `${node.key}`;
+            const u = s.length;
+            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+            if (p < q) {
+                left.push(...new Array(q - p).fill(' '.repeat(n)));
+            }
+            else if (q < p) {
+                right.push(...new Array(p - q).fill(' '.repeat(m)));
+            }
+            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+        };
+        display(beginRoot);
+    }
     /**
      * The function performs a left rotation on a red-black tree node.
      * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
@@ -219,7 +284,7 @@ class RedBlackTree {
     _leftRotate(x) {
         const y = x.right;
         x.right = y.left;
-        if (y.left !== this.NIL) {
+        if (y.left !== exports.NIL) {
             y.left.parent = x;
         }
         y.parent = x.parent;
@@ -243,7 +308,7 @@ class RedBlackTree {
     _rightRotate(x) {
         const y = x.left;
         x.left = y.right;
-        if (y.right !== this.NIL) {
+        if (y.right !== exports.NIL) {
             y.right.parent = x;
         }
         y.parent = x.parent;
@@ -266,7 +331,7 @@ class RedBlackTree {
      */
     _fixDelete(x) {
         let s;
-        while (x !== this.root && x.color === 0) {
+        while (x !== this.root && x.color === types_1.RBTNColor.BLACK) {
             if (x === x.parent.left) {
                 s = x.parent.right;
                 if (s.color === 1) {
@@ -275,12 +340,12 @@ class RedBlackTree {
                     this._leftRotate(x.parent);
                     s = x.parent.right;
                 }
-                if (s.left.color === 0 && s.right.color === 0) {
+                if (s.left !== null && s.left.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
                     s.color = types_1.RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.right.color === 0) {
+                    if (s.right.color === types_1.RBTNColor.BLACK) {
                         s.left.color = types_1.RBTNColor.BLACK;
                         s.color = types_1.RBTNColor.RED;
                         this._rightRotate(s);
@@ -301,12 +366,12 @@ class RedBlackTree {
                     this._rightRotate(x.parent);
                     s = x.parent.left;
                 }
-                if (s.right.color === 0 && s.right.color === 0) {
+                if (s.right.color === types_1.RBTNColor.BLACK && s.right.color === types_1.RBTNColor.BLACK) {
                     s.color = types_1.RBTNColor.RED;
                     x = x.parent;
                 }
                 else {
-                    if (s.left.color === 0) {
+                    if (s.left.color === types_1.RBTNColor.BLACK) {
                         s.right.color = types_1.RBTNColor.BLACK;
                         s.color = types_1.RBTNColor.RED;
                         this._leftRotate(s);

package/dist/mjs/data-structures/binary-tree/tree-multiset.js

@@ -160,7 +160,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
             else if (parent.right === undefined) {
                 parent.right = newNode;
                 if (newNode !== null) {
-                    this._size = (this.size + 1);
+                    this._size = this.size + 1;
                     this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
@@ -263,7 +263,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(identifier, callback);
+        const curr = this.getNode(identifier, callback);
         if (!curr)
             return bstDeletedResult;
         const parent = curr?.parent ? curr.parent : null;