typescript-dsa-stl 2.7.0 → 2.9.0

package/README.md

@@ -2,7 +2,7 @@
 
 **Repository** for the npm package **[typescript-dsa-stl](https://www.npmjs.com/package/typescript-dsa-stl)** · [GitHub](https://github.com/SajidAbdullah729/TypeScript_DSA)
 
-STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**, **Queue**, **Deque**, **List**, **PriorityQueue**, ordered/unordered **Map** and **Set**, **OrderedMultiMap** / **OrderedMultiSet**, **segment trees**, **graph** helpers (BFS, DFS, Dijkstra, Kruskal, DSU), and **string** algorithms (KMP, Rabin–Karp, rolling hash). Install from npm for your app; this repo is the source.
+STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**, **Queue**, **Deque**, **List**, **PriorityQueue**, ordered/unordered **Map** and **Set**, **OrderedMultiMap** / **OrderedMultiSet**, **segment trees**, **graph** helpers (BFS, DFS, topological sort, Dijkstra, Kruskal, DSU), and **string** algorithms (KMP, Rabin–Karp, rolling hash). Install from npm for your app; this repo is the source.
 
 ---
 
@@ -14,11 +14,11 @@ STL-style data structures and algorithms for TypeScript: **Vector**, **Stack**,
 | [Package layout & imports](#package-layout--imports) | Barrel vs subpaths (tree-shaking) |
 | [Quick start](#quick-start) | One file showing main APIs |
 | [API reference](#api-reference) | Export tables |
-| [Complexity](#complexity) | Big-O for collections and segment trees |
+| [Complexity](#complexity) | Big-O for collections |
 | [Collections](#collections) | Deque, nested vectors, multi-map / multi-set |
-| [Segment trees](#segment-trees) | Sum/min/max, generic, lazy |
-| [Graph algorithms](#graph-algorithms) | Adjacency lists, BFS/DFS, components, MST, shortest paths |
-| [String algorithms](#string-algorithms) | KMP, Rabin–Karp, rolling hash |
+| [Segment trees](#segment-trees) | Overview, variants, and examples (one section) |
+| [Graph algorithms](#graph-algorithms) | Adjacency lists, BFS/DFS, topological sort, components, MST, shortest paths |
+| [String algorithms](#string-algorithms) | KMP, Rabin–Karp, Trie, rolling hash |
 | [For maintainers](#for-maintainers) | Build and publish |
 | [License](#license) | MIT |
 
@@ -45,8 +45,11 @@ import {
   binarySearch,
   breadthFirstSearch,
   depthFirstSearch,
+  topologicalSortStack,
+  topologicalSortIndegree,
   KnuthMorrisPratt,
   RabinKarp,
+  Trie,
   StringRollingHash,
 } from 'typescript-dsa-stl/algorithms';
 import { clamp, range } from 'typescript-dsa-stl/utils';
@@ -164,15 +167,15 @@ range(0, 5);            // [0, 1, 2, 3, 4]
 | Area | Exports |
 |------|---------|
 | **Collections** | `Vector`, `Stack`, `Queue`, `Deque`, `List`, `ListNode`, `PriorityQueue`, `OrderedMap`, `UnorderedMap`, `OrderedSet`, `UnorderedSet`, `OrderedMultiMap`, `OrderedMultiSet`, `GeneralSegmentTree`, `SegmentTree`, `SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`, `LazySegmentTreeSum`, `WeightedEdge`, `AdjacencyList`, `WeightedAdjacencyList`, `createAdjacencyList`, `createWeightedAdjacencyList`, `addEdge`, `deleteEdge` |
-| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition`, `DisjointSetUnion`, `KnuthMorrisPratt`, `RabinKarp`, `RABIN_KARP_DEFAULT_MODS`, `StringRollingHash`, `breadthFirstSearch`, `depthFirstSearch`, `connectedComponents`, `kruskalMST`, `dijkstra`, `reconstructPath` |
+| **Algorithms** | `sort`, `find`, `findIndex`, `transform`, `filter`, `reduce`, `reverse`, `unique`, `binarySearch`, `lowerBound`, `upperBound`, `min`, `max`, `partition`, `DisjointSetUnion`, `KnuthMorrisPratt`, `RabinKarp`, `Trie`, `RABIN_KARP_DEFAULT_MODS`, `StringRollingHash`, `breadthFirstSearch`, `depthFirstSearch`, `topologicalSortStack`, `topologicalSortIndegree`, `connectedComponents`, `kruskalMST`, `dijkstra`, `reconstructPath` |
 | **Utils** | `clamp`, `range`, `noop`, `identity`, `swap` |
-| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray`, `RabinKarpTripleMods`, `WeightedUndirectedEdge`, `GeneralSegmentTreeConfig`, `SegmentCombine`, `SegmentMerge`, `SegmentLeafBuild` |
+| **Types** | `Comparator`, `Predicate`, `UnaryFn`, `Reducer`, `IterableLike`, `toArray`, `RabinKarpTripleMods`, `WeightedUndirectedEdge`, `TopologicalSortResult`, `GeneralSegmentTreeConfig`, `SegmentCombine`, `SegmentMerge`, `SegmentLeafBuild` |
 
 ### Subpath imports (tree-shaking)
 
 ```ts
 import { Vector, Stack, Queue, Deque } from 'typescript-dsa-stl/collections';
-import { sort, binarySearch, breadthFirstSearch, depthFirstSearch, KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl/algorithms';
+import { sort, binarySearch, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, KnuthMorrisPratt, RabinKarp, Trie, StringRollingHash } from 'typescript-dsa-stl/algorithms';
 import { clamp, range } from 'typescript-dsa-stl/utils';
 import type { Comparator } from 'typescript-dsa-stl/types';
 ```
@@ -201,12 +204,7 @@ import type { Comparator } from 'typescript-dsa-stl/types';
 \* Amortized (hash).  
 \** At a known node.
 
-### Segment trees
-
-| Structure | Build | Point update | Range query | Extra |
-|-----------|-------|--------------|-------------|--------|
-| **GeneralSegmentTree**, **SegmentTree**, **SegmentTreeSum** / **Min** / **Max** | O(n) | O(log n) | O(log n) | Inclusive `[l, r]`; **GeneralSegmentTree** keeps raw `V` and uses `merge` + `buildLeaf` |
-| **LazySegmentTreeSum** | O(n) | `set`: O(log n) | `rangeSum`: O(log n) | `rangeAdd` on a range: O(log n) |
+Segment-tree time and space behaviour is documented in [Segment trees](#segment-trees) (overview and table at the start of that section).
 
 ---
 
@@ -330,9 +328,33 @@ for (const [key, value] of index) {
 
 ## Segment trees
 
+### Segment tree overview and complexity
+
+A segment tree is an indexable array backed by a tree so **range questions** (sum, min, max, or your own combine) and **updates** cost **O(log n)** instead of scanning the whole slice.
+
 Segment trees support **range queries** and **point updates** in **O(log n)**. Range endpoints are **inclusive**: `query(l, r)` covers indices `l` through `r`.
 
-### Ready-made variants (`SegmentTreeSum`, `SegmentTreeMin`, `SegmentTreeMax`)
+**What each type does:**
+
+| Type | Does |
+|------|------|
+| **SegmentTreeSum** / **Min** / **Max** | Fixed numeric range **sum**, **min**, or **max** with **one index updated at a time**. |
+| **SegmentTree** (generic) | Your own **associative** combine over ranges; same type for array entries and node values. |
+| **GeneralSegmentTree** | Array stores raw **V**, nodes hold a summary **T** built with **merge** and **buildLeaf**. |
+| **LazySegmentTreeSum** | **Add the same delta to a whole range**, optional **single-cell set**, and **range sum** (lazy tags). |
+
+| Structure | Build | Point update | Range query | Extra |
+|-----------|-------|--------------|-------------|--------|
+| **GeneralSegmentTree**, **SegmentTree**, **SegmentTreeSum** / **Min** / **Max** | O(n) | O(log n) | O(log n) | Inclusive `[l, r]`; **GeneralSegmentTree** keeps raw `V` and uses `merge` + `buildLeaf` |
+| **LazySegmentTreeSum** | O(n) | `set`: O(log n) | `rangeSum`: O(log n) | `rangeAdd` on a range: O(log n) |
+
+### Segment tree: Sum, Min, Max and example
+
+- **`SegmentTreeSum`** — answers “what is the **sum** from `l` to `r`?” after you **`update(i, value)`** on one index.
+- **`SegmentTreeMin`** — answers “what is the **minimum** in `[l, r]`?” after single-index updates.
+- **`SegmentTreeMax`** — answers “what is the **maximum** in `[l, r]`?” after single-index updates.
+
+Together they are fixed numeric implementations: build from initial values, **`update(i, value)`** for one index, **`query(l, r)`** for an inclusive range.
 
 ```ts
 import {
@@ -353,9 +375,41 @@ const mx = new SegmentTreeMax([5, 2, 8, 1]);
 console.log(mx.query(0, 3)); // 8
 ```
 
-### Generic `SegmentTree<T>` (custom combine + neutral)
+**Example — analytics / reporting (fixed buckets, range totals, single-day corrections):** each index is a **fixed bucket** (hour, day, version slot, …). You ask for the **sum** from bucket `a` through `b` and sometimes **fix one bucket** after late data or reconciliation — same API as above, wrapped for clarity.
+
+```ts
+import { SegmentTreeSum } from 'typescript-dsa-stl';
+
+/** Revenue (or events, page views, API calls) per calendar day; index 0 = first day of period. */
+class PeriodMetrics {
+  private readonly tree: SegmentTreeSum;
 
-Use the same type for array elements and aggregates. Pass an **associative** `combine` and a **neutral** value for query ranges that miss a segment (e.g. `0` for sum, `Infinity` for min).
+  constructor(dailyValues: readonly number[]) {
+    this.tree = new SegmentTreeSum(dailyValues);
+  }
+
+  /** Total for an inclusive day range — e.g. chart drill-down or export row. */
+  totalBetweenDay(firstDayIndex: number, lastDayIndex: number): number {
+    return this.tree.query(firstDayIndex, lastDayIndex);
+  }
+
+  /** Backfill or correct one day without rebuilding the whole series. */
+  setDay(dayIndex: number, amount: number): void {
+    this.tree.update(dayIndex, amount);
+  }
+}
+
+const january = new PeriodMetrics([1200, 980, 1100, 1050, 1300]);
+console.log(january.totalBetweenDay(0, 4)); // full period
+january.setDay(2, 1150); // corrected day 2
+console.log(january.totalBetweenDay(1, 3)); // sum over days 1..3
+```
+
+In production you would usually **persist** the underlying series in a database and **rebuild** the tree when the period reloads; the tree stays useful in memory for dashboards, simulations, or request handlers that see heavy read/update traffic on the same window.
+
+### Generic SegmentTree
+
+**`SegmentTree<T>`** supports range queries for **any associative operation** (gcd, concatenation, bitwise OR, …) on a fixed-length array, with **point updates**, when element type and aggregate type are the same — pass an **associative** `combine` and a **neutral** value for query ranges that miss a segment (e.g. `0` for sum, `Infinity` for min).
 
 ```ts
 import { SegmentTree } from 'typescript-dsa-stl';
@@ -385,9 +439,11 @@ const strTree = new SegmentTree<string>(
 console.log(strTree.query(0, 2)); // 'abc'
 ```
 
-### `GeneralSegmentTree<T, V>` (custom merge + buildLeaf)
+### GeneralSegmentTree
+
+**`GeneralSegmentTree<T, V>`** keeps **raw** values of type **V** in the array while each segment stores a **different** summary type **T** (e.g. raw numbers in the array, but nodes keep sums of squares or custom stats).
 
-Use when **raw** values `V` differ from the **aggregate** type `T`:
+You supply:
 
 - **`merge(left, right)`** — combine two child aggregates (internal nodes).
 - **`neutral`** — identity for `merge` when a query does not overlap a segment.
@@ -407,9 +463,11 @@ st.update(1, 4);
 console.log(st.rawAt(1)); // 4 — current raw value at index 1
 ```
 
-### `LazySegmentTreeSum` (range add + range sum)
+### LazySegmentTreeSum and example
+
+**`LazySegmentTreeSum`** maintains a numeric array where you can **add a constant to every element in a range**, **overwrite one cell**, and query **range sums** — all in **O(log n)** via lazy propagation (unlike the trees above, which only support point updates).
 
-**`rangeAdd(l, r, delta)`** adds `delta` to every element in the inclusive range. **`rangeSum(l, r)`** returns the sum. **`set(i, value)`** assigns one position (lazy tags are applied along the path). All are **O(log n)**.
+**`rangeAdd(l, r, delta)`** adds `delta` to every element in the inclusive range. **`rangeSum(l, r)`** returns the sum. **`set(i, value)`** assigns one position (lazy tags are applied along the path). All are **O(log n)** — see the complexity table in the overview above.
 
 ```ts
 import { LazySegmentTreeSum } from 'typescript-dsa-stl';
@@ -421,47 +479,7 @@ lazy.set(0, 100);
 console.log(lazy.rangeSum(0, 3)); // 100 + 5 + 5 + 0
 ```
 
-### Real-world use cases
-
-These patterns show up in backends and internal tools when you need **many** range queries and updates on a fixed sequence (length known up front), without scanning the whole array each time.
-
-#### 1. Analytics or reporting: totals over a time window (with corrections)
-
-Each index is a **fixed bucket** (hour of day, day of month, version slot, etc.). You repeatedly ask “what is the **sum** from bucket `a` through `b`?” and sometimes **fix one bucket** after late data or a reconciliation.
-
-```ts
-import { SegmentTreeSum } from 'typescript-dsa-stl';
-
-/** Revenue (or events, page views, API calls) per calendar day; index 0 = first day of period. */
-class PeriodMetrics {
-  private readonly tree: SegmentTreeSum;
-
-  constructor(dailyValues: readonly number[]) {
-    this.tree = new SegmentTreeSum(dailyValues);
-  }
-
-  /** Total for an inclusive day range — e.g. chart drill-down or export row. */
-  totalBetweenDay(firstDayIndex: number, lastDayIndex: number): number {
-    return this.tree.query(firstDayIndex, lastDayIndex);
-  }
-
-  /** Backfill or correct one day without rebuilding the whole series. */
-  setDay(dayIndex: number, amount: number): void {
-    this.tree.update(dayIndex, amount);
-  }
-}
-
-const january = new PeriodMetrics([1200, 980, 1100, 1050, 1300]);
-console.log(january.totalBetweenDay(0, 4)); // full period
-january.setDay(2, 1150); // corrected day 2
-console.log(january.totalBetweenDay(1, 3)); // sum over days 1..3
-```
-
-In production you would usually **persist** the underlying series in a database and **rebuild** the tree when the period reloads; the tree stays useful in memory for dashboards, simulations, or request handlers that see heavy read/update traffic on the same window.
-
-#### 2. Operations or finance: bulk adjustment on a slice, then aggregate
-
-You apply the **same delta** to **every** element in an index range (tiered bonuses, prorated credits, simulation shocks), then need **range sums** for reporting. A lazy sum tree avoids touching each cell one by one.
+**Example — bulk adjustment on a slice, then aggregate:** apply the **same delta** to **every** element in an index range (bonuses, prorated credits, simulation shocks), then query **range sums** without updating each cell one by one.
 
 ```ts
 import { LazySegmentTreeSum } from 'typescript-dsa-stl';
@@ -646,6 +664,117 @@ console.log(breadthFirstSearch(5, withIsolated, 0)); // [0, 1] — not [0,1,2,3,
 - **Disconnected graphs:** run again from another unvisited `start`, or use `connectedComponents` to enumerate components first.
 - **Weighted graphs:** for traversal ignoring weights, use the same vertex lists as the unweighted graph (weights are ignored by these two functions).
 
+### Topological sort
+
+`topologicalSortStack` (iterative DFS / finish order) and `topologicalSortIndegree` (Kahn’s algorithm, zero-indegree queue) both take `n` and a **directed** unweighted `AdjacencyList`. They return `{ order, ok }`: a permutation of `0..n-1` when `ok` is true, or failure when a directed cycle exists.
+
+**When to use**
+
+- **Task / build / dependency ordering:** items must happen only after their prerequisites (package install order, compile steps, course prerequisites).
+- **Scheduling under precedence constraints:** jobs with “A before B” rules and no cycles.
+- **Detecting cycles in a directed model:** if `ok` is false, the graph (on valid vertices `0..n-1`) is not a DAG.
+- **Pick either algorithm:** both answer the same yes/no; choose **stack** if you want DFS-style behavior and an explicit stack; choose **indegree** (Kahn) if you prefer peeling sources level-by-level (often closer to “ready queue” mental models).
+
+**When topological order is not possible**
+
+- Any **directed cycle** (including a **self-loop**): `ok` is false.
+- **Undirected** graphs modeled with **both** `u → v` and `v → u`: that is a 2-cycle, so **not** a DAG unless you only use directed edges that reflect real precedence.
+
+**Example (how to call it and use the result)**
+
+Both functions return the same shape: **`TopologicalSortResult`** — `{ order: number[]; ok: boolean }`.
+
+- **`ok === true`:** `order` is a **permutation of `0..n-1`**; every edge `u → v` appears with `u` before `v` in `order`.
+- **`ok === false`:** **no** full topological order exists (directed cycle). For `topologicalSortStack`, `order` is `[]`. For `topologicalSortIndegree`, `order` may list only some vertices; **do not** treat it as a complete sort.
+
+```ts
+import {
+  createAdjacencyList,
+  addEdge,
+  topologicalSortStack,
+  topologicalSortIndegree,
+  type TopologicalSortResult,
+} from 'typescript-dsa-stl';
+
+const n = 4;
+const g = createAdjacencyList(n);
+addEdge(g, 0, 1);
+addEdge(g, 0, 2);
+addEdge(g, 1, 3);
+addEdge(g, 2, 3);
+
+// Whole result (typed)
+const result: TopologicalSortResult = topologicalSortStack(n, g);
+
+// Usually destructure
+const { order, ok } = topologicalSortIndegree(n, g);
+
+if (ok) {
+  // `order` here is from `topologicalSortIndegree` above → [0, 1, 2, 3] for this graph.
+
+  // 1) See the whole sequence at once
+  console.log(order);
+  // → [ 0, 1, 2, 3 ]   (Node.js / browser consoles may add line breaks or “Array(4)” styling)
+
+  // 2) How many steps (same as n when ok is true)
+  console.log(order.length);
+  // → 4
+
+  // 3) Pick by position: first task, second task, …
+  const first = order[0];
+  const second = order[1];
+  console.log('do vertex', first, 'before', second);
+  // → do vertex 0 before 1
+
+  // 4) Simple loop with indices
+  for (let i = 0; i < order.length; i++) {
+    console.log('step', i + 1, '→ vertex', order[i]);
+  }
+  // → step 1 → vertex 0
+  // → step 2 → vertex 1
+  // → step 3 → vertex 2
+  // → step 4 → vertex 3
+
+  // 5) Same loop, shorter (when you only need the vertex id)
+  for (const vertex of order) {
+    console.log('run job for vertex', vertex);
+  }
+  // → run job for vertex 0
+  // → run job for vertex 1
+  // → run job for vertex 2
+  // → run job for vertex 3
+
+  // 6) Optional: each number is an index into your own list of names
+  const jobNames = ['bootstrap', 'compileA', 'compileB', 'link'];
+  const readable = order.map((vertex) => jobNames[vertex]);
+  console.log(readable.join(' → '));
+  // → bootstrap → compileA → compileB → link
+} else {
+  // No valid order exists (cycle). Use a flag, return early, or show an error.
+  console.error('Graph has a cycle; cannot topologically sort.');
+  // → Graph has a cycle; cannot topologically sort.
+  //   (often printed on stderr; some runtimes prepend “Error” styling)
+}
+
+// Compare algorithms (same `ok` on a given graph; `order` may differ)
+const a = topologicalSortStack(n, g);
+const b = topologicalSortIndegree(n, g);
+console.log(a.ok, b.ok);
+// → true true
+//   (here `a.order` is [0, 2, 1, 3] and `b.order` is [0, 1, 2, 3] — both valid)
+
+// Cycle: 0 → 1 → 2 → 0
+const cyclic = createAdjacencyList(3);
+addEdge(cyclic, 0, 1);
+addEdge(cyclic, 1, 2);
+addEdge(cyclic, 2, 0);
+const bad = topologicalSortStack(3, cyclic);
+console.log(bad.ok);
+// → false
+console.log(bad.order);
+// → []
+```
+
 ### Disjoint Set Union (Union-Find)
 
 Use Union-Find (DSU) to compute connected components efficiently. It merges endpoints of every edge in the adjacency list, so for directed graphs it returns weak connectivity components.
@@ -762,9 +891,9 @@ console.log(path); // [0, 1, 2, 4]
 
 ## String algorithms
 
-### Knuth–Morris–Pratt (KMP), Rabin–Karp, and string rolling hash
+### Knuth–Morris–Pratt (KMP), Rabin–Karp, Trie, and string rolling hash
 
-All three work on **UTF-16 code units** (same as `String` indexing). They solve **different jobs**: KMP and Rabin–Karp are **pattern matchers** (list all start indices of a pattern in a text). `StringRollingHash` is a **substring-hash tool** on a **fixed** string—you combine it with your own logic (equality checks, binary search, etc.).
+All four work on **UTF-16 code units** (same as `String` indexing). KMP and Rabin–Karp are **pattern matchers** (list all start indices of a pattern in a text). `Trie` is a **prefix tree** for fast dictionary operations (`insert`, exact word lookup, prefix lookup, deletion). `StringRollingHash` is a **substring-hash tool** on a **fixed** string—you combine it with your own logic (equality checks, binary search, etc.).
 
 #### When to use which
 
@@ -772,16 +901,18 @@ All three work on **UTF-16 code units** (same as `String` indexing). They solve
 |------|--------|-----|
 | **Find every occurrence** of **one pattern** in **one text**, with **worst-case** O(n + m), **no hashing**, predictable behaviour | **KnuthMorrisPratt** | LPS table; only character comparisons; no modular arithmetic. |
 | **Find every occurrence** of a pattern using a **sliding window** and **hashes** (triple moduli + final verify) | **RabinKarp** | Same asymptotic average case; good when you think in rolling hashes or batch **same-length** patterns. |
+| **Maintain a dynamic dictionary** of words and answer **exact / prefix** queries efficiently | **Trie** | Insert/search/prefix in O(L) where L is key length; natural fit for autocomplete and prefix filtering. |
 | **Many O(1) hash queries** on **substrings of one string** you already hold (compare two ranges, palindrome / LCP style checks, rolling checks without slicing) | **StringRollingHash** | O(n) preprocess, O(1) per `substringHash`; **not** a drop-in “find all matches” API—use KMP or Rabin–Karp for that. |
 
 **Concrete situations**
 
 - **Use KMP** when you need a **guaranteed** linear scan (interviews, strict time bounds, large alphabets), or the pattern is **reused** across many searches (`new KnuthMorrisPratt(pattern)` once, `.search(text)` many times).
 - **Use Rabin–Karp** when a **rolling hash** model fits (e.g. one long stream, one pattern), or you later generalize to **several patterns of the same length** (compare each pattern’s triple hash to each window hash). Triple hashing keeps false hash positives negligible; **verification** still guarantees correct indices.
+- **Use `Trie`** when your workload is dictionary-like: store many words once, then do repeated `search(word)` and `startsWith(prefix)` checks in **O(L)**.
 - **Use `StringRollingHash`** when the problem is **“hash of s[l..r)”** many times on **one** `s`—e.g. check `s[i..i+k) === s[j..j+k)` via hash equality (then confirm if needed), or algorithms that **binary search** on length using substring hashes. For **only** “list all starts of P in T”, pick **KMP** or **Rabin–Karp** instead of building substring hashes by hand.
 
 ```ts
-import { KnuthMorrisPratt, RabinKarp, StringRollingHash } from 'typescript-dsa-stl';
+import { KnuthMorrisPratt, RabinKarp, Trie, StringRollingHash } from 'typescript-dsa-stl';
 
 // A) Pattern fixed, searched in many buffers — build KMP once, call .search() repeatedly (LPS reused).
 const multiDoc = new KnuthMorrisPratt('ERROR');
@@ -793,7 +924,15 @@ const hay = '...long text...';
 KnuthMorrisPratt.findOccurrences(hay, 'needle');
 new RabinKarp('needle').search(hay);
 
-// C) Same static string, many range-equality checks — rolling hash (not for “find all pattern starts” by itself).
+// C) Dictionary/prefix queries — Trie.
+const trie = new Trie();
+trie.insert('apple');
+trie.insert('app');
+trie.search('app');       // true
+trie.startsWith('appl');  // true
+trie.delete('app');       // true
+
+// D) Same static string, many range-equality checks — rolling hash (not for “find all pattern starts” by itself).
 const s = 'banana';
 const rh = new StringRollingHash(s);
 // Does s[1..4) equal s[3..6)? (both length 3)
@@ -809,8 +948,9 @@ const maybe = rh.substringHash(1, 3) === rh.substringHash(3, 3); // then compare
 ```ts
 import {
   KnuthMorrisPratt,
-  StringRollingHash,
   RabinKarp,
+  Trie,
+  StringRollingHash,
   RABIN_KARP_DEFAULT_MODS,
 } from 'typescript-dsa-stl';
 
@@ -847,6 +987,16 @@ console.log(RabinKarp.findOccurrences('aaaa', 'aa')); // [0, 1, 2]
 // Empty pattern: no matches
 console.log(new RabinKarp('').search('text')); // []
 
+// --- Trie: dictionary and prefix queries ---
+const trie = new Trie();
+trie.insert('apple');
+trie.insert('app');
+console.log(trie.search('app')); // true
+console.log(trie.search('ap')); // false
+console.log(trie.startsWith('ap')); // true
+console.log(trie.delete('app')); // true
+console.log(trie.search('app')); // false
+
 // --- String rolling hash: default base 131, mod 1_000_000_007 (both configurable) ---
 const rh = new StringRollingHash('hello');
 // Internally: prefix[] and pow[] so substring hashes are O(1)

package/dist/algorithms/graph.d.ts

@@ -21,6 +21,55 @@ export declare function breadthFirstSearch(n: number, adj: AdjacencyList<number>
  * - Neighbors are explored in the order they appear in `adj[u]` (first neighbor in the list is visited first).
  */
 export declare function depthFirstSearch(n: number, adj: AdjacencyList<number>, start: number): number[];
+/**
+ * Result of a topological sort attempt on vertices `0..n-1`.
+ *
+ * **When sorting is impossible:** classical topological order exists only for a **directed acyclic graph (DAG)**.
+ * If the graph has any **directed cycle** (including a **self-loop**), both algorithms set `ok` to `false`.
+ * Treating an **undirected** edge as two opposite directed arcs creates a 2-cycle, so `ok` will be `false`
+ * unless there are no such pairs (e.g. only isolated vertices).
+ *
+ * **Input:** You must pass **`n` and `adj` together** — `n` is the number of vertices, and `adj[u]` lists **out-neighbors**
+ * of `u` for a **directed** graph. Missing `adj[u]` is treated as no outgoing edges. Neighbors outside `0..n-1` are **ignored**,
+ * so the result reflects that pruned graph, not raw adjacency data with invalid indices.
+ */
+export interface TopologicalSortResult {
+    /** A permutation of `0..n-1` with every edge `u → v` having `u` before `v` (only valid when `ok` is true). */
+    order: number[];
+    /** `true` iff a topological order exists for the directed graph on `0..n-1` after ignoring invalid neighbors. */
+    ok: boolean;
+}
+/**
+ * Topological ordering of a **directed** graph using an explicit stack (iterative DFS / finish times).
+ * Pushes a vertex after all its outgoing edges have been explored, then reverses that list.
+ *
+ * Complexity: O(n + m) time, O(n) extra space.
+ *
+ * **Inputs:** Same as other graph helpers: vertex count `n` and unweighted `adj` (outgoing edges only). This pair **is** the
+ * graph representation here; there is no separate graph object. Keep `n` consistent with how many vertices you number (`0..n-1`).
+ *
+ * **Not possible:** Returns `{ order: [], ok: false }` if a directed cycle is found (self-loop, longer cycle, or bidirectional
+ * undirected modeling). Returns `{ order, ok: true }` for any DAG, including disconnected ones.
+ *
+ * - Invalid neighbor indices are skipped (see {@link TopologicalSortResult}).
+ * - Parallel edges behave like multiple arcs; self-loops are cycles.
+ */
+export declare function topologicalSortStack(n: number, adj: AdjacencyList<number>): TopologicalSortResult;
+/**
+ * Topological ordering via **Kahn's algorithm**: repeatedly remove vertices with indegree zero (BFS-style).
+ * Uses only indegrees derived from `adj`; outdegree is implicit in the lists.
+ *
+ * Complexity: O(n + m) time, O(n) extra space.
+ *
+ * **Inputs:** Requires `n` and `adj` together (directed out-edges per vertex), like {@link topologicalSortStack}.
+ *
+ * **Not possible:** `ok` is `false` when not all vertices are output — equivalently, when the graph on `0..n-1` (after ignoring
+ * invalid neighbors) contains a directed cycle. On failure, `order` lists some vertices in a valid partial order but must not
+ * be treated as a full topological sort.
+ *
+ * - When `ok` is `true`, `order` is one valid topological order; it may differ from the stack/DFS-based order.
+ */
+export declare function topologicalSortIndegree(n: number, adj: AdjacencyList<number>): TopologicalSortResult;
 export interface WeightedUndirectedEdge {
     u: number;
     v: number;

package/dist/algorithms/graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAIpF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,EAC1B,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CAmBV;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,EAC1B,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CAiBV;AAED,MAAM,WAAW,sBAAsB;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,MAAM,EAAE,EAAE,CAQZ;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAgC1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAmCpC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAgBV"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAIpF;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,EAC1B,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CAmBV;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,EAC1B,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CAiBV;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,qBAAqB;IACpC,8GAA8G;IAC9G,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,iHAAiH;IACjH,EAAE,EAAE,OAAO,CAAC;CACb;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,qBAAqB,CAoCvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,qBAAqB,CA0BvB;AAED,MAAM,WAAW,sBAAsB;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GACzB,MAAM,EAAE,EAAE,CAQZ;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAgC1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,qBAAqB,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAmCpC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAgBV"}

package/dist/algorithms/graph.js

@@ -62,6 +62,101 @@ export function depthFirstSearch(n, adj, start) {
     }
     return order;
 }
+/**
+ * Topological ordering of a **directed** graph using an explicit stack (iterative DFS / finish times).
+ * Pushes a vertex after all its outgoing edges have been explored, then reverses that list.
+ *
+ * Complexity: O(n + m) time, O(n) extra space.
+ *
+ * **Inputs:** Same as other graph helpers: vertex count `n` and unweighted `adj` (outgoing edges only). This pair **is** the
+ * graph representation here; there is no separate graph object. Keep `n` consistent with how many vertices you number (`0..n-1`).
+ *
+ * **Not possible:** Returns `{ order: [], ok: false }` if a directed cycle is found (self-loop, longer cycle, or bidirectional
+ * undirected modeling). Returns `{ order, ok: true }` for any DAG, including disconnected ones.
+ *
+ * - Invalid neighbor indices are skipped (see {@link TopologicalSortResult}).
+ * - Parallel edges behave like multiple arcs; self-loops are cycles.
+ */
+export function topologicalSortStack(n, adj) {
+    const state = new Uint8Array(n); // 0 = unvisited, 1 = on stack (visiting), 2 = done
+    const finish = [];
+    const stack = [];
+    for (let s = 0; s < n; s++) {
+        if (state[s] !== 0)
+            continue;
+        state[s] = 1;
+        stack.push({ u: s, i: 0 });
+        while (stack.length > 0) {
+            const top = stack[stack.length - 1];
+            const u = top.u;
+            const neighbors = adj[u] ?? [];
+            let pushedChild = false;
+            while (top.i < neighbors.length) {
+                const v = neighbors[top.i];
+                top.i++;
+                if (v < 0 || v >= n)
+                    continue;
+                if (state[v] === 1)
+                    return { order: [], ok: false };
+                if (state[v] === 0) {
+                    state[v] = 1;
+                    stack.push({ u: v, i: 0 });
+                    pushedChild = true;
+                    break;
+                }
+            }
+            if (!pushedChild) {
+                stack.pop();
+                state[u] = 2;
+                finish.push(u);
+            }
+        }
+    }
+    finish.reverse();
+    return { order: finish, ok: true };
+}
+/**
+ * Topological ordering via **Kahn's algorithm**: repeatedly remove vertices with indegree zero (BFS-style).
+ * Uses only indegrees derived from `adj`; outdegree is implicit in the lists.
+ *
+ * Complexity: O(n + m) time, O(n) extra space.
+ *
+ * **Inputs:** Requires `n` and `adj` together (directed out-edges per vertex), like {@link topologicalSortStack}.
+ *
+ * **Not possible:** `ok` is `false` when not all vertices are output — equivalently, when the graph on `0..n-1` (after ignoring
+ * invalid neighbors) contains a directed cycle. On failure, `order` lists some vertices in a valid partial order but must not
+ * be treated as a full topological sort.
+ *
+ * - When `ok` is `true`, `order` is one valid topological order; it may differ from the stack/DFS-based order.
+ */
+export function topologicalSortIndegree(n, adj) {
+    const indeg = new Uint32Array(n);
+    for (let u = 0; u < n; u++) {
+        for (const v of adj[u] ?? []) {
+            if (v >= 0 && v < n)
+                indeg[v]++;
+        }
+    }
+    const q = [];
+    for (let i = 0; i < n; i++) {
+        if (indeg[i] === 0)
+            q.push(i);
+    }
+    const order = [];
+    let qh = 0;
+    while (qh < q.length) {
+        const u = q[qh++];
+        order.push(u);
+        for (const v of adj[u] ?? []) {
+            if (v < 0 || v >= n)
+                continue;
+            indeg[v]--;
+            if (indeg[v] === 0)
+                q.push(v);
+        }
+    }
+    return { order, ok: order.length === n };
+}
 /**
  * Connected components in an (unweighted) graph using DSU.
  * Complexity: O((n + m) * alpha(n)).

package/dist/algorithms/graph.js.map

@@ -1 +1 @@
-{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../src/algorithms/graph.ts"],"names":[],"mappings":"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"}

package/dist/algorithms/index.d.ts

@@ -3,7 +3,8 @@ export { DisjointSetUnion } from './disjointSetUnion.js';
 export { KnuthMorrisPratt } from './kmp.js';
 export { StringRollingHash } from './stringHashing.js';
 export { RabinKarp, RABIN_KARP_DEFAULT_MODS } from './rabinKarp.js';
+export { Trie } from './trie.js';
 export type { RabinKarpTripleMods } from './rabinKarp.js';
-export type { WeightedUndirectedEdge } from './graph.js';
-export { breadthFirstSearch, depthFirstSearch, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './graph.js';
+export type { WeightedUndirectedEdge, TopologicalSortResult } from './graph.js';
+export { breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './graph.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/algorithms/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/algorithms/index.js

@@ -3,5 +3,6 @@ export { DisjointSetUnion } from './disjointSetUnion.js';
 export { KnuthMorrisPratt } from './kmp.js';
 export { StringRollingHash } from './stringHashing.js';
 export { RabinKarp, RABIN_KARP_DEFAULT_MODS } from './rabinKarp.js';
-export { breadthFirstSearch, depthFirstSearch, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './graph.js';
+export { Trie } from './trie.js';
+export { breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './graph.js';
 //# sourceMappingURL=index.js.map

package/dist/algorithms/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAGpE,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/algorithms/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/algorithms/trie.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Trie (prefix tree) for UTF-16 strings.
+ * Supports insert/search/prefix checks and word removal.
+ */
+export declare class Trie {
+    private readonly root;
+    constructor();
+    /** Insert a word into the trie. */
+    insert(word: string): void;
+    /** Returns true if the exact word exists in the trie. */
+    search(word: string): boolean;
+    /** Returns true if there is any inserted word with this prefix. */
+    startsWith(prefix: string): boolean;
+    /**
+     * Remove one exact word from the trie.
+     * Returns true when the word existed and was removed.
+     */
+    delete(word: string): boolean;
+    /** Returns true when no words have been inserted. */
+    isEmpty(): boolean;
+    private findNode;
+}
+//# sourceMappingURL=trie.d.ts.map

package/dist/algorithms/trie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trie.d.ts","sourceRoot":"","sources":["../../src/algorithms/trie.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;;IAMhC,mCAAmC;IACnC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAc1B,yDAAyD;IACzD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAK7B,mEAAmE;IACnE,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAInC;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAwB7B,qDAAqD;IACrD,OAAO,IAAI,OAAO;IAIlB,OAAO,CAAC,QAAQ;CASjB"}

package/dist/algorithms/trie.js

@@ -0,0 +1,80 @@
+/**
+ * Trie (prefix tree) for UTF-16 strings.
+ * Supports insert/search/prefix checks and word removal.
+ */
+class TrieNode {
+    constructor() {
+        this.children = new Map();
+        this.isWord = false;
+    }
+}
+export class Trie {
+    constructor() {
+        this.root = new TrieNode();
+    }
+    /** Insert a word into the trie. */
+    insert(word) {
+        let node = this.root;
+        for (let i = 0; i < word.length; i++) {
+            const ch = word[i];
+            let next = node.children.get(ch);
+            if (!next) {
+                next = new TrieNode();
+                node.children.set(ch, next);
+            }
+            node = next;
+        }
+        node.isWord = true;
+    }
+    /** Returns true if the exact word exists in the trie. */
+    search(word) {
+        const node = this.findNode(word);
+        return node !== undefined && node.isWord;
+    }
+    /** Returns true if there is any inserted word with this prefix. */
+    startsWith(prefix) {
+        return this.findNode(prefix) !== undefined;
+    }
+    /**
+     * Remove one exact word from the trie.
+     * Returns true when the word existed and was removed.
+     */
+    delete(word) {
+        const path = [];
+        let node = this.root;
+        for (let i = 0; i < word.length; i++) {
+            const ch = word[i];
+            const next = node.children.get(ch);
+            if (!next)
+                return false;
+            path.push({ parent: node, ch, node: next });
+            node = next;
+        }
+        if (!node.isWord)
+            return false;
+        node.isWord = false;
+        // Prune nodes that are no longer needed.
+        for (let i = path.length - 1; i >= 0; i--) {
+            const segment = path[i];
+            if (segment.node.isWord || segment.node.children.size > 0)
+                break;
+            segment.parent.children.delete(segment.ch);
+        }
+        return true;
+    }
+    /** Returns true when no words have been inserted. */
+    isEmpty() {
+        return this.root.children.size === 0;
+    }
+    findNode(path) {
+        let node = this.root;
+        for (let i = 0; i < path.length; i++) {
+            const next = node.children.get(path[i]);
+            if (!next)
+                return undefined;
+            node = next;
+        }
+        return node;
+    }
+}
+//# sourceMappingURL=trie.js.map

package/dist/algorithms/trie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trie.js","sourceRoot":"","sources":["../../src/algorithms/trie.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -7,8 +7,8 @@
  */
 export { Vector, Stack, Queue, Deque, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
 export type { WeightedEdge, AdjacencyList, WeightedAdjacencyList, GeneralSegmentTreeConfig, SegmentCombine, SegmentLeafBuild, SegmentMerge, } from './collections/index.js';
-export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
-export type { WeightedUndirectedEdge, RabinKarpTripleMods } from './algorithms/index.js';
+export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, Trie, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
+export type { WeightedUndirectedEdge, RabinKarpTripleMods, TopologicalSortResult, } from './algorithms/index.js';
 export { clamp, range, noop, identity, swap } from './utils/index.js';
 export type { Comparator, Predicate, UnaryFn, Reducer, IterableLike } from './types/index.js';
 export { toArray } from './types/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,IAAI,EACJ,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACtE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -6,7 +6,7 @@
  * import { Vector, Stack, Queue, List, sort, binarySearch, clamp } from 'typescript-dsa-stl';
  */
 export { Vector, Stack, Queue, Deque, List, ListNode, PriorityQueue, OrderedMap, UnorderedMap, OrderedSet, UnorderedSet, OrderedMultiSet, OrderedMultiMap, addEdge, deleteEdge, createAdjacencyList, createWeightedAdjacencyList, GeneralSegmentTree, SegmentTree, SegmentTreeSum, SegmentTreeMin, SegmentTreeMax, LazySegmentTreeSum, } from './collections/index.js';
-export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
+export { sort, find, findIndex, transform, filter, reduce, reverse, unique, binarySearch, lowerBound, upperBound, min, max, partition, DisjointSetUnion, KnuthMorrisPratt, StringRollingHash, RabinKarp, Trie, RABIN_KARP_DEFAULT_MODS, breadthFirstSearch, depthFirstSearch, topologicalSortStack, topologicalSortIndegree, connectedComponents, dijkstra, reconstructPath, kruskalMST, } from './algorithms/index.js';
 export { clamp, range, noop, identity, swap } from './utils/index.js';
 export { toArray } from './types/index.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAUhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,aAAa,EACb,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,2BAA2B,EAC3B,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAUhC,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,GAAG,EACH,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,IAAI,EACJ,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,UAAU,GACX,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-dsa-stl",
-  "version": "2.7.0",
+  "version": "2.9.0",
   "description": "STL-style data structures and algorithms for TypeScript: Vector, Stack, Queue, Deque (double-ended queue), List, PriorityQueue, Map, Set, sort, binarySearch, graph utilities. Use like C++ STL.",
   "type": "module",
   "main": "dist/index.js",
@@ -54,6 +54,7 @@
     "queue",
     "deque",
     "double-ended-queue",
+    "graph",
     "list",
     "priority-queue",
     "map",