[**data-structure-typed**](../README.md)

***

[data-structure-typed](../README.md) / TreeMultiMap

# Class: TreeMultiMap\<K, V, R\>

Defined in: [data-structures/binary-tree/tree-multi-map.ts:28](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L28)

TreeMultiMap (ordered MultiMap) — key → bucket (Array of values).

Semantics (RFC):
- Bucketed design: each key appears once; duplicates live in the bucket.
- `get(key)` returns a **live** bucket reference.
- Default iteration yields bucket entries: `[K, V[]]`.
- Navigable operations (`first/last/ceiling/...`) return entry tuples like TreeMap.

## Example

```ts
// Morris traversal (O(1) space)
 const tmm = new TreeMultiMap<number>([5, 3, 7]);
    const result = tmm.morris(n => n.key, 'IN');
    console.log(result.length); // > 0;
```

## Type Parameters

### K

`K` = `any`

### V

`V` = `any`

### R

`R` = `any`

## Implements

- `Iterable`\<\[`K`, `V`[]\]\>

## Constructors

### Constructor

```ts
new TreeMultiMap<K, V, R>(keysNodesEntriesOrRaws?, options?): TreeMultiMap<K, V, R>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:45](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L45)

Creates a new TreeMultiMap.

#### Parameters

##### keysNodesEntriesOrRaws?

`Iterable`\<
  \| `K`
  \| `R`
  \| \[`K` \| `null` \| `undefined`, `V`[] \| `undefined`\]
  \| `null`
  \| `undefined`\> = `[]`

Initial entries, or raw elements if `toEntryFn` is provided.

##### options?

`TreeMultiMapOptions`\<`K`, `V`[], `R`\> = `{}`

Configuration options including optional `toEntryFn` to transform raw elements.

#### Returns

`TreeMultiMap`\<`K`, `V`, `R`\>

#### Remarks

Time O(m log m), Space O(m) where m is the number of initial entries

#### Example

```ts
// Standard usage with entries
const mmap = new TreeMultiMap([['a', ['x', 'y']], ['b', ['z']]]);

// Using toEntryFn to transform raw objects
const players = [{ score: 100, items: ['sword'] }, { score: 200, items: ['shield', 'bow'] }];
const mmap = new TreeMultiMap(players, { toEntryFn: p => [p.score, p.items] });
```

## Accessors

### comparator

#### Get Signature

```ts
get comparator(): Comparator<K>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:5413](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L5413)

Expose comparator for advanced usage/testing (read-only).

##### Remarks

Time O(1), Space O(1)

##### Returns

`Comparator`\<`K`\>

***

### size

#### Get Signature

```ts
get size(): number;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:109](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L109)

Number of distinct keys.

##### Remarks

Time O(1), Space O(1)

##### Returns

`number`

***

### totalSize

#### Get Signature

```ts
get totalSize(): number;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:616](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L616)

Total number of values across all buckets (Σ bucket.length).

##### Remarks

Time O(n), Space O(1)

 *

##### Example

```ts
// Total number of values
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      mm.add(2, 'c');
      console.log(mm.totalSize); // 3;
```

##### Returns

`number`

## Methods

### \[iterator\]()

```ts
iterator: Iterator<[K, V[]]>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2029](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2029)

Iterates over all entries as [key, bucket] pairs.

#### Returns

`Iterator`\<\[`K`, `V`[]\]\>

#### Remarks

Time O(n), Space O(1)

#### Implementation of

```ts
Iterable.[iterator]
```

***

### add()

```ts
add(key, value): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:1326](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L1326)

Append a single value.

#### Parameters

##### key

`K`

##### value

`V`

#### Returns

`boolean`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Add key-value pair
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      mm.add(2, 'c');
      console.log(mm.get(1)); // ['a', 'b'];
```

***

### ceiling()

```ts
ceiling(key): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:3126](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L3126)

Returns the entry with the smallest key >= given key.

#### Parameters

##### key

`K`

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Least key ≥ target
 const mm = new TreeMultiMap<number, string>();
      mm.add(10, 'a');
      mm.add(20, 'b');
      mm.add(30, 'c');
      console.log(mm.ceiling(15)?.[0]); // 20;
```

***

### clear()

```ts
clear(): void;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:520](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L520)

Removes all entries from the map.

#### Returns

`void`

#### Remarks

Time O(1), Space O(1)

 *

#### Example

```ts
// Remove all entries
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.clear();
      console.log(mm.isEmpty()); // true;
```

***

### clone()

```ts
clone(): TreeMultiMap<K, V, R>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:5405](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L5405)

Deep copy

 *

#### Returns

`TreeMultiMap`\<`K`, `V`, `R`\>

#### Example

```ts
// Deep clone
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      const copy = mm.clone();
      copy.delete(1);
      console.log(mm.has(1)); // true;
```

***

### count()

```ts
count(key): number;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:567](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L567)

Bucket length for a key (missing => 0).

#### Parameters

##### key

`K`

#### Returns

`number`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Count values for key
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      console.log(mm.count(1)); // 2;
```

***

### delete()

```ts
delete(key): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:1856](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L1856)

Deletes a key and its entire bucket.

#### Parameters

##### key

`K`

#### Returns

`boolean`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Remove key
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(2, 'b');
      mm.delete(1);
      console.log(mm.has(1)); // false;
```

***

### deleteValue()

```ts
deleteValue(
   key, 
   value, 
   eq?): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:1954](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L1954)

Delete a single occurrence of a value from a key's bucket.

#### Parameters

##### key

`K`

##### value

`V`

##### eq?

(`a`, `b`) => `boolean`

#### Returns

`boolean`

#### Remarks

Time O(log n + m), Space O(1) where m is bucket size

 *

#### Example

```ts
// Delete specific value
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      mm.deleteValue(1, 'a');
      console.log(mm.get(1)); // ['b'];
```

***

### deleteValues()

```ts
deleteValues(
   key, 
   value, 
   eq?): number;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2009](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2009)

Delete all occurrences of a value from a key's bucket.

#### Parameters

##### key

`K`

##### value

`V`

##### eq?

(`a`, `b`) => `boolean`

#### Returns

`number`

#### Remarks

Time O(log n + m), Space O(1) where m is bucket size

 *

#### Example

```ts
// Delete all matching values
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'a');
      mm.add(1, 'b');
      const count = mm.deleteValues(1, 'a');
      console.log(count); // 2;
```

***

### entries()

```ts
entries(): IterableIterator<[K, V[]]>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2472](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2472)

Iterate over all `[key, values[]]` entries (Map-compatible).

#### Returns

`IterableIterator`\<\[`K`, `V`[]\]\>

#### Remarks

Time O(n), Space O(1) per step.

 *

#### Example

```ts
// Iterate over entries
 const mm = new TreeMultiMap<number, string>();
    mm.set(1, 'a');
    mm.set(1, 'b');
    mm.set(2, 'c');
    console.log([...mm.entries()]); // [
 //      [1, ['a', 'b']],
 //      [2, ['c']]
 //    ];
```

***

### entriesOf()

```ts
entriesOf(key): IterableIterator<[K, V]>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2521](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2521)

Iterates over all entries for a specific key.

#### Parameters

##### key

`K`

#### Returns

`IterableIterator`\<\[`K`, `V`\]\>

#### Remarks

Time O(log n + m), Space O(1) where m is bucket size

 *

#### Example

```ts
// Get entries for key
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      console.log([...mm.entriesOf(1)]); // [[1, 'a'], [1, 'b']];
```

***

### filter()

```ts
filter(predicate): TreeMultiMap<K, V, R>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:4317](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L4317)

Creates a new map with entries that pass the predicate.

#### Parameters

##### predicate

(`value`, `key`, `map`) => `boolean`

#### Returns

`TreeMultiMap`\<`K`, `V`, `R`\>

#### Remarks

Time O(n), Space O(n)

 *

#### Example

```ts
// Filter entries
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(2, 'b');
      mm.add(3, 'c');
      const filtered = mm.filter((v, k) => k > 1);
      console.log([...filtered.keys()]); // [2, 3];
```

***

### first()

```ts
first(): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2714](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2714)

Returns the entry with the smallest key.

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// First entry
 const mm = new TreeMultiMap<number, string>();
      mm.add(3, 'c');
      mm.add(1, 'a');
      console.log(mm.first()?.[0]); // 1;
```

***

### flatEntries()

```ts
flatEntries(): IterableIterator<[K, V]>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2620](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2620)

Iterates over all [key, value] pairs (flattened from buckets).

#### Returns

`IterableIterator`\<\[`K`, `V`\]\>

#### Remarks

Time O(T), Space O(1) where T is totalSize

 *

#### Example

```ts
// All key-value pairs flattened
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      mm.add(2, 'c');
      console.log([...mm.flatEntries()]); // [[1, 'a'], [1, 'b'], [2, 'c']];
```

***

### floor()

```ts
floor(key): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:3341](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L3341)

Returns the entry with the largest key <= given key.

#### Parameters

##### key

`K`

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Greatest key ≤ target
 const mm = new TreeMultiMap<number, string>();
      mm.add(10, 'a');
      mm.add(20, 'b');
      mm.add(30, 'c');
      console.log(mm.floor(25)?.[0]); // 20;
```

***

### forEach()

```ts
forEach(callback): void;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:4106](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L4106)

Executes a callback for each entry.

#### Parameters

##### callback

(`value`, `key`, `map`) => `void`

#### Returns

`void`

#### Remarks

Time O(n), Space O(1)

 *

#### Example

```ts
// Iterate entries
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(2, 'b');
      const keys: number[] = [];
      mm.forEach((v, k) => keys.push(k));
      console.log(keys); // [1, 2];
```

***

### get()

```ts
get(key): V[] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:1123](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L1123)

Live bucket reference (do not auto-delete key if bucket becomes empty via mutation).

#### Parameters

##### key

`K`

#### Returns

`V`[] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Get values for key
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      console.log(mm.get(1)); // ['a', 'b'];
```

***

### getByRank()

```ts
getByRank(k): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:5294](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L5294)

Creates a shallow clone of this map.

#### Parameters

##### k

`number`

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(n log n), Space O(n)

 *

#### Example

```ts
// Order-statistic on BST
 const tree = new TreeMultiMap<number>([30, 10, 50, 20, 40], { enableOrderStatistic: true });
      console.log(tree.getByRank(0)); // 10;
      console.log(tree.getByRank(4)); // 50;
      console.log(tree.getRank(30)); // 2;
```

***

### getRank()

```ts
getRank(key): number;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:5313](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L5313)

Get the rank of a key in sorted order

#### Parameters

##### key

`K`

#### Returns

`number`

#### Example

```ts
// Get the rank of a key in sorted order
 const tree = new TreeMultiMap<number>(
        [10, 20, 30, 40, 50],
        { enableOrderStatistic: true }
      );
      console.log(tree.getRank(10)); // 0;  // smallest → rank 0
      console.log(tree.getRank(30)); // 2;  // 2 elements before 30 in tree order
      console.log(tree.getRank(50)); // 4;  // largest → rank 4
      console.log(tree.getRank(25)); // 2;
```

***

### has()

```ts
has(key): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:870](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L870)

Whether the map contains the given key.

#### Parameters

##### key

`K`

#### Returns

`boolean`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Check key existence
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      console.log(mm.has(1)); // true;
      console.log(mm.has(2)); // false;
```

***

### hasEntry()

```ts
hasEntry(
   key, 
   value, 
   eq?): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:1904](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L1904)

Check if a specific value exists in a key's bucket.

#### Parameters

##### key

`K`

##### value

`V`

##### eq?

(`a`, `b`) => `boolean`

#### Returns

`boolean`

#### Remarks

Time O(log n + m), Space O(1) where m is bucket size

 *

#### Example

```ts
// Check specific key-value
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      console.log(mm.hasEntry(1, 'a')); // true;
      console.log(mm.hasEntry(1, 'z')); // false;
```

***

### higher()

```ts
higher(key): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:3513](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L3513)

Returns the entry with the smallest key > given key.

#### Parameters

##### key

`K`

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Least key > target
 const mm = new TreeMultiMap<number, string>();
      mm.add(10, 'a');
      mm.add(20, 'b');
      console.log(mm.higher(10)?.[0]); // 20;
```

***

### isEmpty()

```ts
isEmpty(): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:313](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L313)

Whether the map is empty.

#### Returns

`boolean`

#### Remarks

Time O(1), Space O(1)

 *

#### Example

```ts
// Check if empty
 console.log(new TreeMultiMap().isEmpty()); // true;
```

***

### keys()

```ts
keys(): IterableIterator<K>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2239](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2239)

Iterates over all keys.

#### Returns

`IterableIterator`\<`K`\>

#### Remarks

Time O(n), Space O(1)

 *

#### Example

```ts
// Iterate keys
 const mm = new TreeMultiMap<number, string>();
      mm.add(3, 'c');
      mm.add(1, 'a');
      console.log([...mm.keys()]); // [1, 3];
```

***

### last()

```ts
last(): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2807](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2807)

Returns the entry with the largest key.

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Last entry
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(3, 'c');
      console.log(mm.last()?.[0]); // 3;
```

***

### lower()

```ts
lower(key): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:3685](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L3685)

Returns the entry with the largest key < given key.

#### Parameters

##### key

`K`

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Greatest key < target
 const mm = new TreeMultiMap<number, string>();
      mm.add(10, 'a');
      mm.add(20, 'b');
      console.log(mm.lower(20)?.[0]); // 10;
```

***

### map()

```ts
map<V2>(mapper): TreeMultiMap<K, V2, R>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:4528](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L4528)

Creates a new map by transforming each entry.

#### Type Parameters

##### V2

`V2`

#### Parameters

##### mapper

(`value`, `key`, `map`) => \[`K`, `V2`[]\]

#### Returns

`TreeMultiMap`\<`K`, `V2`, `R`\>

#### Remarks

Time O(n log n), Space O(n)

 *

#### Example

```ts
// Transform values
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      const mapped = mm.map((v, k) => [k, v.map(s => s.toUpperCase())] as [number, string[]]);
      console.log(mapped.get(1)); // ['A'];
```

***

### pollFirst()

```ts
pollFirst(): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2860](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2860)

Removes and returns the entry with the smallest key.

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Remove and return first
 const mm = new TreeMultiMap<number, string>();
      mm.add(2, 'b');
      mm.add(1, 'a');
      const first = mm.pollFirst();
      console.log(first?.[0]); // 1;
      console.log(mm.has(1)); // false;
```

***

### pollLast()

```ts
pollLast(): [K, V[]] | undefined;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2912](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2912)

Removes and returns the entry with the largest key.

#### Returns

\[`K`, `V`[]\] \| `undefined`

#### Remarks

Time O(log n), Space O(1)

 *

#### Example

```ts
// Remove and return last
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(3, 'c');
      const last = mm.pollLast();
      console.log(last?.[0]); // 3;
```

***

### print()

```ts
print(): void;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:3897](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L3897)

Prints the internal tree structure (for debugging).

#### Returns

`void`

#### Remarks

Time O(n), Space O(n)

 *

#### Example

```ts
// Display tree
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      expect(() => mm.print()).not.toThrow();
```

***

### rangeByRank()

```ts
rangeByRank(start, end): [K, V[]][];
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:5349](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L5349)

Get elements by rank range

 *

#### Parameters

##### start

`number`

##### end

`number`

#### Returns

\[`K`, `V`[]\][]

#### Example

```ts
// Pagination by position in tree order
 const tree = new TreeMultiMap<number>(
        [10, 20, 30, 40, 50, 60, 70, 80, 90],
        { enableOrderStatistic: true }
      );
      const pageSize = 3;

      // Page 1
      console.log(tree.rangeByRank(0, pageSize - 1)); // [10, 20, 30];
      // Page 2
      console.log(tree.rangeByRank(pageSize, 2 * pageSize - 1)); // [40, 50, 60];
      // Page 3
      console.log(tree.rangeByRank(2 * pageSize, 3 * pageSize - 1)); // [70, 80, 90];
```

***

### rangeSearch()

```ts
rangeSearch<C>(range, callback?): ReturnType<C>[];
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:5119](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L5119)

Searches for entries within a key range.

#### Type Parameters

##### C

`C` *extends* (`node`) => `unknown`

#### Parameters

##### range

`Range`\<`K`\> \| \[`K`, `K`\]

##### callback?

`C`

#### Returns

`ReturnType`\<`C`\>[]

#### Remarks

Time O(log n + k), Space O(k) where k is result size

 *

#### Example

```ts
// Find keys in range
 const mm = new TreeMultiMap<number, string>();
      mm.add(10, 'a');
      mm.add(20, 'b');
      mm.add(30, 'c');
      const result = mm.rangeSearch([15, 25]);
      console.log(result.length); // 1;
```

***

### reduce()

```ts
reduce<U>(callback, initialValue): U;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:4742](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L4742)

Reduces all entries to a single value.

#### Type Parameters

##### U

`U`

#### Parameters

##### callback

(`accumulator`, `value`, `key`, `map`) => `U`

##### initialValue

`U`

#### Returns

`U`

#### Remarks

Time O(n), Space O(1)

 *

#### Example

```ts
// Aggregate
 const mm = new TreeMultiMap<number, number>();
      mm.add(1, 10);
      mm.add(2, 20);
      const sum = mm.reduce((acc, v) => acc + v.reduce((a, b) => a + b, 0), 0);
      console.log(sum); // 30;
```

***

### set()

#### Call Signature

```ts
set(entry, value?): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:1582](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L1582)

Alias for compatibility with existing TreeMultiMap semantics.

##### Parameters

###### entry

  \| `K`
  \| \[`K` \| `null` \| `undefined`, `V`[] \| `undefined`\]
  \| `null`
  \| `undefined`

###### value?

`V`

##### Returns

`boolean`

##### Remarks

Time O(log n), Space O(1) for single value; O(log n + m) for bucket append

 *

##### Example

```ts
// Set values for key
 const mm = new TreeMultiMap<number, string>();
      mm.set(1, 'a');
      mm.set(1, 'b');
      console.log(mm.get(1)); // ['a', 'b'];
```

#### Call Signature

```ts
set(key, value): boolean;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:1583](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L1583)

Alias for compatibility with existing TreeMultiMap semantics.

##### Parameters

###### key

`K`

###### value

`V`

##### Returns

`boolean`

##### Remarks

Time O(log n), Space O(1) for single value; O(log n + m) for bucket append

 *

##### Example

```ts
// Set values for key
 const mm = new TreeMultiMap<number, string>();
      mm.set(1, 'a');
      mm.set(1, 'b');
      console.log(mm.get(1)); // ['a', 'b'];
```

***

### setMany()

```ts
setMany(keysNodesEntriesOrRaws): boolean[];
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:4944](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L4944)

Sets multiple entries at once.

#### Parameters

##### keysNodesEntriesOrRaws

`Iterable`\<`K` \| \[`K` \| `null` \| `undefined`, `V`[] \| `undefined`\]\>

#### Returns

`boolean`[]

#### Remarks

Time O(m log n), Space O(m) where m is input size

 *

#### Example

```ts
// Set multiple entries
 const mm = new TreeMultiMap<number, string>();
      mm.setMany([[1, ['a']], [2, ['b']]]);
      console.log(mm.size); // 2;
```

***

### values()

```ts
values(): IterableIterator<V[]>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2446](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2446)

Iterates over all buckets.

#### Returns

`IterableIterator`\<`V`[]\>

#### Remarks

Time O(n), Space O(1)

 *

#### Example

```ts
// Iterate value arrays
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      console.log([...mm.values()]); // [['a', 'b']];
```

***

### valuesOf()

```ts
valuesOf(key): IterableIterator<V>;
```

Defined in: [data-structures/binary-tree/tree-multi-map.ts:2570](https://github.com/zrwusa/data-structure-typed/blob/main/src/data-structures/binary-tree/tree-multi-map.ts#L2570)

Iterates over all values for a specific key.

#### Parameters

##### key

`K`

#### Returns

`IterableIterator`\<`V`\>

#### Remarks

Time O(log n + m), Space O(1) where m is bucket size

 *

#### Example

```ts
// Get flat values for key
 const mm = new TreeMultiMap<number, string>();
      mm.add(1, 'a');
      mm.add(1, 'b');
      console.log([...mm.valuesOf(1)]); // ['a', 'b'];
```