data-structure-typed 2.5.2 → 2.6.0

package/SPECIFICATION.md

@@ -101,21 +101,35 @@
 
 ```typescript
 // Add operations
-structure.push(element: T): number          // Add to end, return length
-structure.unshift(element: T): number       // Add to start, return length
+structure.push(element: T): boolean         // Add to end
+structure.unshift(element: T): boolean      // Add to start
 
 // Remove operations
 structure.pop(): T | undefined              // Remove from end
 structure.shift(): T | undefined            // Remove from start
+structure.delete(element: T): boolean       // Remove first match
+structure.deleteAt(index: number): T | undefined  // Remove at index
+structure.deleteWhere(pred: Function): boolean     // Remove first match by predicate
 
 // Peek operations (read without removing)
-structure.peek(): T | undefined             // View last element
-structure.peekFirst(): T | undefined        // View first element (Deque)
-structure.peekLast(): T | undefined         // View last element (Deque)
+structure.peek(): T | undefined             // View front element (Queue/Deque/Stack)
+structure.first: T | undefined              // View first element (getter)
+structure.last: T | undefined               // View last element (getter)
+
+// Search (back-to-front)
+structure.findLast(pred: Function): T | undefined   // Deque, DoublyLinkedList
+structure.findLastIndex(pred: Function): number     // Deque, DoublyLinkedList
+
+// Array-compatible (migration helpers)
+structure.includes(element: T): boolean     // Alias for has()
+structure.entries(): IterableIterator<[number, T]>  // [index, value] pairs
+structure.keys(): IterableIterator<number>  // Index iterator
+structure.toReversed(): this                // Non-mutating reverse (new instance)
 
 // Size and queries
-structure.size: number                      // Element count
-structure.isEmpty: boolean                  // Check if empty
+structure.size: number                      // Element count (Stack, Trie, etc.)
+structure.length: number                    // Element count (Queue, Deque, LinkedList)
+structure.isEmpty(): boolean                // Check if empty
 ```
 
 ### Tree & Map API
@@ -124,8 +138,8 @@ structure.isEmpty: boolean                  // Check if empty
 
 ```typescript
 // Add/update
-structure.set(key: K, value: V): this
-structure.setMany(entries: [K, V][]): this
+structure.set(key: K, value: V): this       // Returns this for chaining (Map/HashMap)
+structure.setMany(entries: [K, V][]): boolean[]
 
 // Query
 structure.get(key: K): V | undefined
@@ -134,6 +148,7 @@ structure.size: number
 
 // Remove
 structure.delete(key: K): boolean
+structure.deleteWhere(pred: Function): boolean  // TreeMap/TreeSet/LinkedHashMap
 structure.clear(): void
 
 // Iteration
@@ -148,19 +163,34 @@ structure.entries(): IterableIterator<[K, V]>
 
 ```typescript
 // Add/remove
-heap.push(element: T): number               // Add element
-heap.add(element: T): number                // Alias for push
-heap.pop(): T | undefined                  // Remove highest/lowest priority
-heap.poll(): T | undefined                 // Alias for pop
+heap.add(element: T): boolean               // Add element
+heap.pop(): T | undefined                   // Remove highest/lowest priority
+heap.poll(): T | undefined                  // Deprecated — use pop()
+heap.delete(element: T): boolean            // Remove first match
+heap.deleteWhere(pred: Function): boolean   // Remove first match by predicate
 
 // Peek
 heap.peek(): T | undefined                 // View highest/lowest without removing
 
 // Query
 heap.size: number
-heap.isEmpty: boolean
+heap.isEmpty(): boolean
 ```
 
+### TreeSet — ES2025 Set Operations
+
+```typescript
+treeSet.union(other: Iterable<K>): TreeSet<K>
+treeSet.intersection(other: Iterable<K>): TreeSet<K>
+treeSet.difference(other: Iterable<K>): TreeSet<K>
+treeSet.symmetricDifference(other: Iterable<K>): TreeSet<K>
+treeSet.isSubsetOf(other: Iterable<K>): boolean
+treeSet.isSupersetOf(other: Iterable<K>): boolean
+treeSet.isDisjointFrom(other: Iterable<K>): boolean
+```
+
+All accept any `Iterable<K>` (TreeSet, native Set, Array, generators).
+
 ### Array Methods (Available on All Structures)
 
 **All structures support ES6+ array methods via iteration:**

package/SPECIFICATION.zh-CN.md

@@ -101,21 +101,35 @@
 
 ```typescript
 // 添加操作
-structure.push(element: T): number          // 添加到末尾，返回长度
-structure.unshift(element: T): number       // 添加到开头，返回长度
+structure.push(element: T): boolean         // 添加到末尾
+structure.unshift(element: T): boolean      // 添加到开头
 
 // 删除操作
 structure.pop(): T | undefined              // 从末尾删除
 structure.shift(): T | undefined            // 从开头删除
+structure.delete(element: T): boolean       // 删除第一个匹配
+structure.deleteAt(index: number): T | undefined  // 按索引删除
+structure.deleteWhere(pred: Function): boolean     // 按条件删除第一个匹配
 
 // 查看操作（读取但不删除）
-structure.peek(): T | undefined             // 查看最后一个元素
-structure.peekFirst(): T | undefined        // 查看第一个元素（Deque）
-structure.peekLast(): T | undefined         // 查看最后一个元素（Deque）
+structure.peek(): T | undefined             // 查看队头元素（Queue/Deque/Stack）
+structure.first: T | undefined              // 查看第一个元素（getter）
+structure.last: T | undefined               // 查看最后一个元素（getter）
+
+// 反向查找
+structure.findLast(pred: Function): T | undefined   // Deque、DoublyLinkedList
+structure.findLastIndex(pred: Function): number     // Deque、DoublyLinkedList
+
+// Array 兼容（方便迁移）
+structure.includes(element: T): boolean     // has() 的别名
+structure.entries(): IterableIterator<[number, T]>  // [index, value] 对
+structure.keys(): IterableIterator<number>  // 索引迭代器
+structure.toReversed(): this                // 非破坏性反转（返回新实例）
 
 // 大小和查询
-structure.size: number                      // 元素数量
-structure.isEmpty: boolean                  // 检查是否为空
+structure.size: number                      // 元素数量（Stack、Trie 等）
+structure.length: number                    // 元素数量（Queue、Deque、LinkedList）
+structure.isEmpty(): boolean                // 检查是否为空
 ```
 
 ### 树和映射 API
@@ -124,8 +138,8 @@ structure.isEmpty: boolean                  // 检查是否为空
 
 ```typescript
 // 添加/更新
-structure.set(key: K, value: V): this
-structure.setMany(entries: [K, V][]): this
+structure.set(key: K, value: V): this       // 返回 this 支持链式调用（Map/HashMap）
+structure.setMany(entries: [K, V][]): boolean[]
 
 // 查询
 structure.get(key: K): V | undefined
@@ -134,6 +148,7 @@ structure.size: number
 
 // 删除
 structure.delete(key: K): boolean
+structure.deleteWhere(pred: Function): boolean  // TreeMap/TreeSet/LinkedHashMap
 structure.clear(): void
 
 // 迭代
@@ -148,19 +163,34 @@ structure.entries(): IterableIterator<[K, V]>
 
 ```typescript
 // 添加/删除
-heap.push(element: T): number               // 添加元素
-heap.add(element: T): number                // push 的别名
-heap.pop(): T | undefined                  // 删除最高/最低优先级
-heap.poll(): T | undefined                 // pop 的别名
+heap.add(element: T): boolean               // 添加元素
+heap.pop(): T | undefined                   // 删除最高/最低优先级
+heap.poll(): T | undefined                  // 已废弃 — 请使用 pop()
+heap.delete(element: T): boolean            // 删除第一个匹配
+heap.deleteWhere(pred: Function): boolean   // 按条件删除第一个匹配
 
 // 查看
 heap.peek(): T | undefined                 // 查看最高/最低优先级但不删除
 
 // 查询
 heap.size: number
-heap.isEmpty: boolean
+heap.isEmpty(): boolean
 ```
 
+### TreeSet — ES2025 集合操作
+
+```typescript
+treeSet.union(other: Iterable<K>): TreeSet<K>              // 并集
+treeSet.intersection(other: Iterable<K>): TreeSet<K>       // 交集
+treeSet.difference(other: Iterable<K>): TreeSet<K>         // 差集
+treeSet.symmetricDifference(other: Iterable<K>): TreeSet<K>// 对称差集
+treeSet.isSubsetOf(other: Iterable<K>): boolean            // 子集判断
+treeSet.isSupersetOf(other: Iterable<K>): boolean          // 超集判断
+treeSet.isDisjointFrom(other: Iterable<K>): boolean        // 不相交判断
+```
+
+接受任何 `Iterable<K>`（TreeSet、原生 Set、数组、生成器）。
+
 ### 数组方法（所有结构上可用）
 
 **所有结构通过迭代支持 ES6+ 数组方法：**