Update MultiRedBlackTree.ts

Author: masx200

finding-mk-average/MultiRedBlackTree.ts

@@ -3,23 +3,27 @@ import { Direction } from "https://deno.land/std@0.173.0/collections/binary_sear
 import { RedBlackNode } from "https://deno.land/std@0.173.0/collections/red_black_node.ts";
 import RedBlackTreeExtended from "../dinner-plate-stacks/RedBlackTree.ts";
 
+
 export class MultiRedBlackTree<T> extends RedBlackTreeExtended<T> {
     hash: (v: T) => any;
     constructor(
         compare: (a: T, b: T) => number = ascend,
-        hash: (v: T) => any = (v) => v,
+        hash: (v: T) => any = (v) => v
     ) {
         super(compare);
         this.hash = hash;
     }
     value2count = new Map<any, number>();
 
     getCount(value: T): number {
-        return this.value2count.get(this.hash(value)) ?? 1;
+        return this.value2count.get(this.hash(value)) ?? 0;
     }
     setCount(value: T, count: number) {
         return this.value2count.set(this.hash(value), count);
     }
+    hasCount(value: T) {
+        return (this.value2count.get(this.hash(value)) ?? 0) > 0;
+    }
     root: RedBlackNode<T> | null = null;
     getRoot(): RedBlackNode<T> | null {
         return this.root;
@@ -29,9 +33,9 @@ export class MultiRedBlackTree<T> extends RedBlackTreeExtended<T> {
     }
     remove(value: T): boolean {
         // console.log("remove", value);
-        const node = this.findNode(value);
+        // const node = this.findNode(value);
 
-        if (!node) {
+        if (!this.hasCount(value)) {
             return false;
         } else {
             // node.count--;
@@ -47,34 +51,34 @@ export class MultiRedBlackTree<T> extends RedBlackTreeExtended<T> {
         }
     }
     insert(value: T): boolean {
-        const node = this.findNode(value);
+        // const node = this.findNode(value);
 
-        if (node) {
+        if (this.hasCount(value)) {
             // node.count++;
             this.setCount(value, (this.getCount(value) ?? 1) + 1);
             // console.log("increment", node);
             return true;
         } else {
-            // this.insertGetNode(value);
-            super.insert(value);
+            this.insertGetNode(value);
+            // super.insert(value);
+            this.setCount(value, 1);
         }
         return true;
     }
     insertGetNode(value: T): RedBlackNode<T> | null {
         let node = this.insertNode(
             RedBlackNode,
-            value,
+            value
         ) as RedBlackNode<T> | null;
         if (node) this.setCount(value, 1);
 
         if (node) {
             while (node.parent?.red) {
                 let parent: RedBlackNode<T> = node.parent!;
-                const parentDirection: Direction = parent
-                    .directionFromParent()!;
-                const uncleDirection: Direction = parentDirection === "right"
-                    ? "left"
-                    : "right";
+                const parentDirection: Direction =
+                    parent.directionFromParent()!;
+                const uncleDirection: Direction =
+                    parentDirection === "right" ? "left" : "right";
                 const uncle: RedBlackNode<T> | null =
                     parent.parent![uncleDirection] ?? null;