data-structure-typed 2.4.5 → 2.5.1

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

@@ -0,0 +1,1117 @@
+[**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/2f6ceb3aee852228efc88b111e19c0809753e805/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/2f6ceb3aee852228efc88b111e19c0809753e805/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/2f6ceb3aee852228efc88b111e19c0809753e805/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:398](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L398)
+
+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:2832](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2832)
+
+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:837](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L837)
+
+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:3483](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L3483)
+
+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:700](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L700)
+
+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:1243](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L1243)
+
+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:1951](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L1951)
+
+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:1671](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L1671)
+
+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:2232](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2232)
+
+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:2574](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2574)
+
+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:2954](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2954)
+
+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:1385](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L1385)
+
+Visit each value in ascending order.
+
+Callback follows native Set convention: `(value, value2, set)`.
+
+ *
+
+#### Parameters
+
+##### cb
+
+(`value`, `value2`, `set`) => `void`
+
+##### thisArg?
+
+`any`
+
+#### 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];
+```
+
+***
+
+### has()
+
+```ts
+has(key): boolean;
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:549](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L549)
+
+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:3074](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L3074)
+
+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:234](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L234)
+
+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:971](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L971)
+
+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:2614](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2614)
+
+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:3194](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L3194)
+
+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:1523](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L1523)
+
+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:2656](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2656)
+
+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:2700](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2700)
+
+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:2509](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2509)
+
+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();
+```
+
+***
+
+### rangeSearch()
+
+```ts
+rangeSearch(range, options?): K[];
+```
+
+Defined in: [data-structures/binary-tree/tree-set.ts:3328](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L3328)
+
+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:1815](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L1815)
+
+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:2091](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2091)
+
+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:2374](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L2374)
+
+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:1107](https://github.com/zrwusa/data-structure-typed/blob/2f6ceb3aee852228efc88b111e19c0809753e805/src/data-structures/binary-tree/tree-set.ts#L1107)
+
+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/2f6ceb3aee852228efc88b111e19c0809753e805/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`\>