data-structure-typed 2.5.0 → 2.5.2

package/docs-site-docusaurus/docs/api/classes/TreeSet.md

@@ -0,0 +1,1246 @@
+[**data-structure-typed**](../README.md)
+
+***
+
+[data-structure-typed](../README.md) / TreeSet
+
+# Class: TreeSet\<K, R\>
+
+Defined in: [data-structures/binary-tree/tree-set.ts:26](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L26)
+
+An ordered Set backed by a red-black tree.
+
+- Iteration order is ascending by key.
+- No node exposure: all APIs use keys only.
+
+## Example
+
+```ts
+// Set multiple key-value pairs
+ const ts = new TreeSet<number, string>();
+    ts.setMany([[1, 'a'], [2, 'b'], [3, 'c']]);
+    console.log(ts.size); // 3;
+```
+
+## Type Parameters
+
+### K
+
+`K` = `any`
+
+### R
+
+`R` = `K`
+
+## Implements
+
+- `Iterable`\<`K`\>
+
+## Constructors
+
+### Constructor
+
+```ts
+new TreeSet<K, R>(elements?, options?): TreeSet<K, R>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:46](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L46)
+
+Create a TreeSet from an iterable of keys or raw elements.
+
+#### Parameters
+
+##### elements?
+
+`Iterable`\<`K`, `any`, `any`\> \| `Iterable`\<`R`, `any`, `any`\>
+
+Iterable of keys, or raw elements if `toElementFn` is provided.
+
+##### options?
+
+`TreeSetOptions`\<`K`, `R`\> = `{}`
+
+Configuration options including optional `toElementFn` to transform raw elements.
+
+#### Returns
+
+`TreeSet`\<`K`, `R`\>
+
+#### Throws
+
+When using the default comparator and encountering unsupported key types,
+or invalid keys (e.g. `NaN`, invalid `Date`).
+
+#### Example
+
+```ts
+// Standard usage with keys
+const set = new TreeSet([3, 1, 2]);
+
+// Using toElementFn to transform raw objects
+const users = [{ id: 3, name: 'Alice' }, { id: 1, name: 'Bob' }];
+const set = new TreeSet<number, User>(users, { toElementFn: u => u.id });
+```
+
+## Accessors
+
+### size
+
+#### Get Signature
+
+```ts
+get size(): number;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:101](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L101)
+
+Number of elements in the set.
+
+##### Returns
+
+`number`
+
+## Methods
+
+### add()
+
+```ts
+add(key): this;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:468](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L468)
+
+Add a key to the set (no-op if already present).
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`this`
+
+#### Remarks
+
+Expected time O(log n)
+
+ *
+
+#### Example
+
+```ts
+// Unique tags with sorted order
+ const tags = new TreeSet<string>(['javascript', 'typescript', 'react', 'typescript', 'node']);
+
+    // Duplicates removed, sorted alphabetically
+    console.log([...tags]); // ['javascript', 'node', 'react', 'typescript'];
+    console.log(tags.size); // 4;
+
+    tags.add('angular');
+    console.log(tags.first()); // 'angular';
+    console.log(tags.last()); // 'typescript';
+```
+
+***
+
+### ceiling()
+
+```ts
+ceiling(key): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3483](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3483)
+
+Smallest key that is >= the given key.
+
+ *
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Finding nearest available time slot
+ // Available appointment times (minutes from midnight)
+    const slots = new TreeSet<number>([540, 600, 660, 720, 840, 900]);
+
+    // Customer wants something around 10:30 (630 min)
+    const nearest = slots.ceiling(630);
+    console.log(nearest); // 660; // 11:00 AM
+
+    // What's the latest slot before 2:00 PM (840)?
+    const before2pm = slots.lower(840);
+    console.log(before2pm); // 720; // 12:00 PM
+
+    // Book the 11:00 slot
+    slots.delete(660);
+    console.log(slots.ceiling(630)); // 720;
+```
+
+***
+
+### clear()
+
+```ts
+clear(): void;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:1012](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L1012)
+
+Remove all keys.
+
+ *
+
+#### Returns
+
+`void`
+
+#### Example
+
+```ts
+// Remove all
+ const ts = new TreeSet<number>([1, 2]);
+      ts.clear();
+      console.log(ts.isEmpty()); // true;
+```
+
+***
+
+### clone()
+
+```ts
+clone(): TreeSet<K>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:4341](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L4341)
+
+Creates a shallow clone of this set.
+
+#### Returns
+
+`TreeSet`\<`K`\>
+
+#### Remarks
+
+Time O(n log n), Space O(n)
+
+ *
+
+#### Example
+
+```ts
+// Deep clone
+ const ts = new TreeSet<number>([1, 2, 3]);
+      const copy = ts.clone();
+      copy.delete(1);
+      console.log(ts.has(1)); // true;
+```
+
+***
+
+### delete()
+
+```ts
+delete(key): boolean;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:840](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L840)
+
+Delete a key.
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`boolean`
+
+`true` if the key existed; otherwise `false`.
+
+#### Remarks
+
+Expected time O(log n)
+
+ *
+
+#### Example
+
+```ts
+// Removing elements while maintaining order
+ const nums = new TreeSet<number>([1, 3, 5, 7, 9]);
+
+    console.log(nums.delete(5)); // true;
+    console.log(nums.delete(5)); // false; // already gone
+    console.log([...nums]); // [1, 3, 7, 9];
+```
+
+***
+
+### entries()
+
+```ts
+entries(): IterableIterator<[K, K]>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:1523](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L1523)
+
+Iterate over `[value, value]` pairs (native Set convention).
+
+Note: TreeSet stores only keys internally; `[k, k]` is created on-the-fly during iteration.
+
+ *
+
+#### Returns
+
+`IterableIterator`\<\[`K`, `K`\]\>
+
+#### Example
+
+```ts
+// Iterate entries
+ const ts = new TreeSet<number>([3, 1, 2]);
+      console.log([...ts.entries()].map(([k]) => k)); // [1, 2, 3];
+```
+
+***
+
+### every()
+
+```ts
+every(callbackfn, thisArg?): boolean;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:2406](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L2406)
+
+Test whether all values satisfy a predicate.
+
+#### Parameters
+
+##### callbackfn
+
+`TreeSetElementCallback`\<`K`, `boolean`, `TreeSet`\<`K`, `K`\>\>
+
+##### thisArg?
+
+`unknown`
+
+#### Returns
+
+`boolean`
+
+#### Remarks
+
+Time O(n), Space O(1)
+
+ *
+
+#### Example
+
+```ts
+// Test all
+ const ts = new TreeSet<number>([2, 4, 6]);
+      console.log(ts.every(k => k > 0)); // true;
+```
+
+***
+
+### filter()
+
+```ts
+filter(callbackfn, thisArg?): TreeSet<K>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:2056](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L2056)
+
+Create a new TreeSet containing only values that satisfy the predicate.
+
+#### Parameters
+
+##### callbackfn
+
+`TreeSetElementCallback`\<`K`, `boolean`, `TreeSet`\<`K`, `K`\>\>
+
+##### thisArg?
+
+`unknown`
+
+#### Returns
+
+`TreeSet`\<`K`\>
+
+#### Remarks
+
+Time O(n log n) expected, Space O(n)
+
+ *
+
+#### Example
+
+```ts
+// Filter
+ const ts = new TreeSet<number>([1, 2, 3, 4, 5]);
+      const evens = ts.filter(k => k % 2 === 0);
+      console.log([...evens]); // [2, 4];
+```
+
+***
+
+### find()
+
+```ts
+find(callbackfn, thisArg?): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:2757](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L2757)
+
+Find the first value that satisfies a predicate.
+
+#### Parameters
+
+##### callbackfn
+
+`TreeSetElementCallback`\<`K`, `boolean`, `TreeSet`\<`K`, `K`\>\>
+
+##### thisArg?
+
+`unknown`
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Remarks
+
+Time O(n), Space O(1)
+
+ *
+
+#### Example
+
+```ts
+// Find entry
+ const ts = new TreeSet<number>([1, 2, 3]);
+      const found = ts.find(k => k === 2);
+      console.log(found); // 2;
+```
+
+***
+
+### first()
+
+```ts
+first(): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3176](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3176)
+
+Smallest key in the set.
+
+ *
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Student grade ranking with custom comparator
+ interface Student {
+      name: string;
+      gpa: number;
+    }
+
+    const ranking = new TreeSet<Student>(
+      [
+        { name: 'Alice', gpa: 3.8 },
+        { name: 'Bob', gpa: 3.5 },
+        { name: 'Charlie', gpa: 3.9 },
+        { name: 'Diana', gpa: 3.5 }
+      ],
+      { comparator: (a, b) => b.gpa - a.gpa || a.name.localeCompare(b.name) }
+    );
+
+    // Sorted by GPA descending, then name ascending
+    const names = [...ranking].map(s => s.name);
+    console.log(names); // ['Charlie', 'Alice', 'Bob', 'Diana'];
+
+    // Top student
+    console.log(ranking.first()?.name); // 'Charlie';
+
+    // Filter students with GPA >= 3.8
+    const honors = ranking.filter(s => s.gpa >= 3.8);
+    console.log(honors.toArray().map(s => s.name)); // ['Charlie', 'Alice'];
+```
+
+***
+
+### floor()
+
+```ts
+floor(key): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3633](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3633)
+
+Largest key that is <= the given key.
+
+ *
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Largest element ≤ target
+ const breakpoints = new TreeSet<number>([320, 768, 1024, 1280, 1920]);
+
+    // Current width is 800 → which breakpoint applies?
+    console.log(breakpoints.floor(800)); // 768;
+    console.log(breakpoints.floor(1024)); // 1024; // exact match
+    console.log(breakpoints.floor(100)); // undefined;
+```
+
+***
+
+### forEach()
+
+```ts
+forEach(cb, thisArg?): void;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:1700](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L1700)
+
+Visit each value in ascending order.
+
+Callback follows native Set convention: `(value, value2, set)`.
+
+ *
+
+#### Parameters
+
+##### cb
+
+(`value`, `value2`, `set`) => `void`
+
+##### thisArg?
+
+`unknown`
+
+#### Returns
+
+`void`
+
+#### Example
+
+```ts
+// Execute for each
+ const ts = new TreeSet<number>([3, 1, 2]);
+      const keys: number[] = [];
+      ts.forEach(k => keys.push(k));
+      console.log(keys); // [1, 2, 3];
+```
+
+***
+
+### getByRank()
+
+```ts
+getByRank(k): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:4127](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L4127)
+
+Returns the element at the k-th position in tree order (0-indexed).
+
+#### Parameters
+
+##### k
+
+`number`
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Remarks
+
+Time O(log n). Requires `enableOrderStatistic: true`.
+
+ *
+
+#### Example
+
+```ts
+// Find k-th element in a TreeSet
+ const set = new TreeSet<number>([30, 10, 50, 20, 40], { enableOrderStatistic: true });
+      console.log(set.getByRank(0)); // 10;
+      console.log(set.getByRank(2)); // 30;
+      console.log(set.getRank(30)); // 2;
+```
+
+***
+
+### getRank()
+
+```ts
+getRank(key): number;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:4145](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L4145)
+
+Returns the 0-based rank of a key (number of elements that precede it in tree order).
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`number`
+
+#### Remarks
+
+Time O(log n). Requires `enableOrderStatistic: true`.
+ *
+
+#### Example
+
+```ts
+// Get the rank of a key in sorted order
+ const tree = new TreeSet<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-set.ts:654](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L654)
+
+Test whether a key exists.
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`boolean`
+
+#### Remarks
+
+Expected time O(log n)
+
+ *
+
+#### Example
+
+```ts
+// Checking membership in a sorted collection
+ const allowed = new TreeSet<string>(['admin', 'editor', 'viewer']);
+
+    console.log(allowed.has('admin')); // true;
+    console.log(allowed.has('guest')); // false;
+```
+
+***
+
+### higher()
+
+```ts
+higher(key): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3781](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3781)
+
+Smallest key that is > the given key.
+
+ *
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Smallest element strictly > target
+ const levels = new TreeSet<number>([1, 5, 10, 25, 50, 100]);
+
+    console.log(levels.higher(10)); // 25;
+    console.log(levels.higher(100)); // undefined;
+```
+
+***
+
+### isEmpty()
+
+```ts
+isEmpty(): boolean;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:269](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L269)
+
+Whether the set is empty.
+
+ *
+
+#### Returns
+
+`boolean`
+
+#### Example
+
+```ts
+// Check empty
+ console.log(new TreeSet().isEmpty()); // true;
+```
+
+***
+
+### keys()
+
+```ts
+keys(): IterableIterator<K>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:1181](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L1181)
+
+Iterate over keys in ascending order.
+
+ *
+
+#### Returns
+
+`IterableIterator`\<`K`\>
+
+#### Example
+
+```ts
+// Get sorted keys
+ const ts = new TreeSet<number>([30, 10, 20]);
+      console.log([...ts.keys()]); // [10, 20, 30];
+```
+
+***
+
+### last()
+
+```ts
+last(): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3223](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3223)
+
+Largest key in the set.
+
+ *
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Get the maximum element
+ const temps = new TreeSet<number>([18, 22, 15, 30, 25]);
+    console.log(temps.last()); // 30;
+    console.log(temps.first()); // 15;
+```
+
+***
+
+### lower()
+
+```ts
+lower(key): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3929](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3929)
+
+Largest key that is < the given key.
+
+ *
+
+#### Parameters
+
+##### key
+
+`K`
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Largest element strictly < target
+ const tiers = new TreeSet<number>([100, 200, 500, 1000]);
+
+    console.log(tiers.lower(500)); // 200;
+    console.log(tiers.lower(100)); // undefined;
+```
+
+***
+
+### map()
+
+```ts
+map<MK>(
+   callbackfn, 
+   options?, 
+thisArg?): TreeSet<MK>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:1873](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L1873)
+
+Create a new TreeSet by mapping each value to a new key.
+
+This mirrors `RedBlackTree.map`: mapping produces a new ordered container.
+
+#### Type Parameters
+
+##### MK
+
+`MK`
+
+#### Parameters
+
+##### callbackfn
+
+`TreeSetElementCallback`\<`K`, `MK`, `TreeSet`\<`K`, `K`\>\>
+
+##### options?
+
+`Omit`\<`TreeSetOptions`\<`MK`, `MK`\>, `"toElementFn"`\> & `object` = `{}`
+
+##### thisArg?
+
+`unknown`
+
+#### Returns
+
+`TreeSet`\<`MK`\>
+
+#### Remarks
+
+Time O(n log n) expected, Space O(n)
+
+ *
+
+#### Example
+
+```ts
+// Transform
+ const ts = new TreeSet<number>([1, 2, 3]);
+      const doubled = ts.map(k => k * 2);
+      console.log([...doubled]); // [2, 4, 6];
+```
+
+***
+
+### pollFirst()
+
+```ts
+pollFirst(): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3272](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3272)
+
+Remove and return the smallest key.
+
+ *
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Remove and return minimum
+ const queue = new TreeSet<number>([5, 1, 8, 3]);
+
+    console.log(queue.pollFirst()); // 1;
+    console.log(queue.pollFirst()); // 3;
+    console.log(queue.size); // 2;
+```
+
+***
+
+### pollLast()
+
+```ts
+pollLast(): K | undefined;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3323](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3323)
+
+Remove and return the largest key.
+
+ *
+
+#### Returns
+
+`K` \| `undefined`
+
+#### Example
+
+```ts
+// Remove and return maximum
+ const stack = new TreeSet<number>([10, 20, 30]);
+
+    console.log(stack.pollLast()); // 30;
+    console.log(stack.size); // 2;
+```
+
+***
+
+### print()
+
+```ts
+print(): void;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3104](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L3104)
+
+Print a human-friendly representation.
+
+#### Returns
+
+`void`
+
+#### Remarks
+
+Time O(n), Space O(n)
+
+ *
+
+#### Example
+
+```ts
+// Display tree
+ const ts = new TreeSet<number>([1, 2, 3]);
+      expect(() => ts.print()).not.toThrow();
+```
+
+***
+
+### rangeByRank()
+
+```ts
+rangeByRank(start, end): K[];
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:4168](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L4168)
+
+Returns elements by rank range (0-indexed, inclusive on both ends).
+
+#### Parameters
+
+##### start
+
+`number`
+
+##### end
+
+`number`
+
+#### Returns
+
+`K`[]
+
+#### Remarks
+
+Time O(log n + k). Requires `enableOrderStatistic: true`.
+
+ *
+
+#### Example
+
+```ts
+// Pagination with rangeByRank
+ const tree = new TreeSet<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(range, options?): K[];
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:4091](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L4091)
+
+Return all keys in a given range.
+
+#### Parameters
+
+##### range
+
+\[`K`, `K`\]
+
+`[low, high]`
+
+##### options?
+
+`TreeSetRangeOptions` = `{}`
+
+Inclusive/exclusive bounds (defaults to inclusive).
+
+ *
+
+#### Returns
+
+`K`[]
+
+#### Example
+
+```ts
+// IP address blocklist with range checking
+ // Simplified: use numeric IP representation
+    const blocklist = new TreeSet<number>([
+      167772160, // 10.0.0.0
+      167772416, // 10.0.1.0
+      167772672, // 10.0.2.0
+      167773184  // 10.0.4.0
+    ]);
+
+    // Check if any blocked IP is in range 10.0.1.0 - 10.0.3.0
+    const inRange = blocklist.rangeSearch([167772416, 167772928]);
+    console.log(inRange); // [167772416, 167772672];
+
+    // Quick membership check
+    console.log(blocklist.has(167772416)); // true;
+    console.log(blocklist.has(167772800)); // false;
+```
+
+***
+
+### reduce()
+
+```ts
+reduce<A>(callbackfn, initialValue): A;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:2235](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L2235)
+
+Reduce values into a single accumulator.
+
+#### Type Parameters
+
+##### A
+
+`A`
+
+#### Parameters
+
+##### callbackfn
+
+`TreeSetReduceCallback`\<`K`, `A`, `TreeSet`\<`K`, `K`\>\>
+
+##### initialValue
+
+`A`
+
+#### Returns
+
+`A`
+
+#### Remarks
+
+Time O(n), Space O(1)
+
+ *
+
+#### Example
+
+```ts
+// Aggregate
+ const ts = new TreeSet<number>([1, 2, 3]);
+      const sum = ts.reduce((acc, k) => acc + k, 0);
+      console.log(sum); // 6;
+```
+
+***
+
+### some()
+
+```ts
+some(callbackfn, thisArg?): boolean;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:2581](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L2581)
+
+Test whether any value satisfies a predicate.
+
+#### Parameters
+
+##### callbackfn
+
+`TreeSetElementCallback`\<`K`, `boolean`, `TreeSet`\<`K`, `K`\>\>
+
+##### thisArg?
+
+`unknown`
+
+#### Returns
+
+`boolean`
+
+#### Remarks
+
+Time O(n), Space O(1)
+
+ *
+
+#### Example
+
+```ts
+// Test any
+ const ts = new TreeSet<number>([1, 3, 5]);
+      console.log(ts.some(k => k === 3)); // true;
+```
+
+***
+
+### toArray()
+
+```ts
+toArray(): K[];
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:2934](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L2934)
+
+Materialize the set into an array of keys.
+
+#### Returns
+
+`K`[]
+
+#### Remarks
+
+Time O(n), Space O(n)
+
+ *
+
+#### Example
+
+```ts
+// Convert to array
+ const ts = new TreeSet<number>([3, 1, 2]);
+      console.log(ts.toArray()); // [1, 2, 3];
+```
+
+***
+
+### values()
+
+```ts
+values(): IterableIterator<K>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:1352](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L1352)
+
+Iterate over values in ascending order.
+
+Note: for Set-like containers, `values()` is the same as `keys()`.
+
+ *
+
+#### Returns
+
+`IterableIterator`\<`K`\>
+
+#### Example
+
+```ts
+// Get values (same as keys for Set)
+ const ts = new TreeSet<number>([2, 1, 3]);
+      console.log([...ts.values()]); // [1, 2, 3];
+```
+
+***
+
+### createDefaultComparator()
+
+```ts
+static createDefaultComparator<K>(): Comparator<K>;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:71](https://github.com/zrwusa/data-structure-typed/blob/8292cb978daf85ebe846186c7c7572aece04fb7b/src/data-structures/binary-tree/tree-set.ts#L71)
+
+Create the strict default comparator.
+
+Supports:
+- `number` (rejects `NaN`; treats `-0` and `0` as equal)
+- `string`
+- `Date` (orders by `getTime()`, rejects invalid dates)
+
+For other key types, a custom comparator must be provided.
+
+#### Type Parameters
+
+##### K
+
+`K`
+
+#### Returns
+
+`Comparator`\<`K`\>