data-structure-typed 1.46.4 → 1.46.6

package/dist/umd/data-structure-typed.js

@@ -554,7 +554,7 @@ var dataStructureTyped = (() => {
     set(key, value) {
       let node;
       if (isWeakKey(key)) {
-        const hash = key;
+        const hash = this._objHashFn(key);
         node = this._objMap.get(hash);
         if (node) {
           node.value = value;
@@ -6534,7 +6534,7 @@ var dataStructureTyped = (() => {
     return RBTNColor2;
   })(RBTNColor || {});
 
-  // src/types/helpers.ts
+  // src/types/common.ts
   var CP = /* @__PURE__ */ ((CP2) => {
     CP2["lt"] = "lt";
     CP2["eq"] = "eq";
@@ -7941,7 +7941,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+     * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      */
@@ -7950,56 +7950,34 @@ var dataStructureTyped = (() => {
       if (!beginRoot)
         return;
       const display = (root) => {
-        const [lines, , ,] = _displayAux(root);
+        const [lines, , ,] = this._displayAux(root);
         for (const line of lines) {
           console.log(line);
         }
       };
-      const _displayAux = (node) => {
-        if (!this.isRealNode(node)) {
-          return [[], 0, 0, 0];
-        }
-        if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
-          const line = `${node.key}`;
-          const width = line.length;
-          const height = 1;
-          const middle = Math.floor(width / 2);
-          return [[line], width, height, middle];
-        }
-        if (this.isRealNode(node) && !this.isRealNode(node.right)) {
-          const [lines, n2, p2, x2] = _displayAux(node.left);
-          const s2 = `${node.key}`;
-          const u2 = s2.length;
-          const first_line2 = " ".repeat(x2 + 1) + "_".repeat(n2 - x2 - 1) + s2;
-          const second_line2 = " ".repeat(x2) + "/" + " ".repeat(n2 - x2 - 1 + u2);
-          const shifted_lines = lines.map((line) => line + " ".repeat(u2));
-          return [[first_line2, second_line2, ...shifted_lines], n2 + u2, p2 + 2, n2 + Math.floor(u2 / 2)];
-        }
-        if (this.isRealNode(node) && !this.isRealNode(node.left)) {
-          const [lines, n2, p2, u2] = _displayAux(node.right);
-          const s2 = `${node.key}`;
-          const x2 = s2.length;
-          const first_line2 = s2 + "_".repeat(x2) + " ".repeat(n2 - x2);
-          const second_line2 = " ".repeat(u2 + x2) + "\\" + " ".repeat(n2 - x2 - 1);
-          const shifted_lines = lines.map((line) => " ".repeat(u2) + line);
-          return [[first_line2, second_line2, ...shifted_lines], n2 + x2, p2 + 2, Math.floor(u2 / 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);
     }
+    _displayAux(node) {
+      if (!node) {
+        return [["\u2500"], 1, 0, 0];
+      }
+      const line = node.key.toString();
+      const width = line.length;
+      if (!node.left && !node.right) {
+        return [[line], width, 1, Math.floor(width / 2)];
+      }
+      const [leftLines, leftWidth, leftHeight, leftMiddle] = node.left ? this._displayAux(node.left) : [[""], 0, 0, 0];
+      const [rightLines, rightWidth, rightHeight, rightMiddle] = node.right ? this._displayAux(node.right) : [[""], 0, 0, 0];
+      const firstLine = " ".repeat(Math.max(0, leftMiddle + 1)) + "_".repeat(Math.max(0, leftWidth - leftMiddle - 1)) + line + "_".repeat(Math.max(0, rightMiddle)) + " ".repeat(Math.max(0, rightWidth - rightMiddle));
+      const secondLine = (leftHeight > 0 ? " ".repeat(leftMiddle) + "/" + " ".repeat(leftWidth - leftMiddle - 1) : " ".repeat(leftWidth)) + " ".repeat(width) + (rightHeight > 0 ? " ".repeat(rightMiddle) + "\\" + " ".repeat(rightWidth - rightMiddle - 1) : " ".repeat(rightWidth));
+      const mergedLines = [firstLine, secondLine];
+      for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
+        const leftLine = i < leftHeight ? leftLines[i] : " ".repeat(leftWidth);
+        const rightLine = i < rightHeight ? rightLines[i] : " ".repeat(rightWidth);
+        mergedLines.push(leftLine + " ".repeat(width) + rightLine);
+      }
+      return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+    }
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.
@@ -9560,10 +9538,14 @@ var dataStructureTyped = (() => {
       let x = this.root;
       while (x !== this.NIL) {
         y = x;
-        if (x && node.key < x.key) {
-          x = x.left;
-        } else {
-          x = x == null ? void 0 : x.right;
+        if (x) {
+          if (node.key < x.key) {
+            x = x.left;
+          } else if (node.key > x.key) {
+            x = x == null ? void 0 : x.right;
+          } else {
+            return;
+          }
         }
       }
       node.parent = y;