@blackglory/structures 0.10.0 → 0.10.1

package/dist/es2018/index.mjs

@@ -9642,9 +9642,15 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
 }
 
 class SparseSet {
-    constructor() {
+    constructor(array = []) {
         this.indexToValue = [];
-        this.valueToIndex = [];
+        const valueToIndex = [];
+        if (array.length > 0) {
+            for (const [index, value] of array.entries()) {
+                valueToIndex[value] = index;
+            }
+        }
+        this.valueToIndex = valueToIndex;
     }
     get [Symbol.toStringTag]() {
         return this.constructor.name;
@@ -9981,5 +9987,194 @@ function computeNewCapacity(oldCapacity, targetLength, growthFactor) {
     }
 }
 
-export { BadEventError, Box, DynamicTypedArray, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SparseMap, SparseSet, TLRUMap, TrieMap, TypedSparseMap, TypedSparseSet, convertArrayToCons, convertConsToArray };
+class SkipListNode {
+    constructor(value) {
+        this.value = value;
+        this.previous = null;
+        this.next = null;
+        this.up = null;
+        this.down = null;
+    }
+}
+class SkipList {
+    constructor(compare) {
+        this.compare = compare;
+        // 最顶层的首个节点
+        this.head = new SkipListNode(null);
+        // 最顶层的最后一个节点
+        this.tail = new SkipListNode(null);
+        this.height = 0;
+        this._size = 0;
+        this.head.next = this.tail;
+        this.tail.previous = this.head;
+    }
+    // 元素数量
+    get size() {
+        return this._size;
+    }
+    *elements() {
+        let currentNode = this.head;
+        while (currentNode.down) {
+            currentNode = currentNode.down;
+        }
+        while (currentNode.next && es2018$e.isntNull(currentNode.next.value)) {
+            currentNode = currentNode.next;
+            yield currentNode;
+        }
+    }
+    dumpList() {
+        const result = [];
+        let head = this.head;
+        do {
+            result.push([]);
+            let currentNode = head;
+            do {
+                result[result.length - 1].push(currentNode.value);
+                currentNode = currentNode.next;
+            } while (currentNode);
+        } while (head = head.down);
+        return result;
+    }
+    delete(value) {
+        let currentNode = this.findNode(value);
+        while (currentNode) {
+            // 被删除的节点肯定不会是head或tail, 因此一定有previous
+            currentNode.previous.next = currentNode.next;
+            // 被删除的节点肯定不会是head或tail, 因此一定有next
+            currentNode.next.previous = currentNode.previous;
+            currentNode = currentNode.down;
+        }
+        this._size--;
+    }
+    has(value) {
+        return es2018$e.isntNull(this.findNode(value));
+    }
+    findNode(value) {
+        let currentNode = this.head;
+        while (true) {
+            while (currentNode.next && es2018$e.isntNull(currentNode.next.value)) {
+                const result = this.compare(currentNode.next.value, value);
+                if (result === 0) {
+                    return currentNode.next;
+                }
+                else if (result < 0) {
+                    currentNode = currentNode.next;
+                }
+                else {
+                    break;
+                }
+            }
+            if (currentNode.down) {
+                currentNode = currentNode.down;
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    add(value) {
+        let previousNode = this.findPreviousNode(value);
+        // 如果previousNode.next.value等于value, 则说明value已经存在
+        if (previousNode.next &&
+            es2018$e.isntNull(previousNode.next.value) &&
+            this.compare(previousNode.next.value, value) === 0) {
+            return;
+        }
+        let newNode = new SkipListNode(value);
+        // 在底层加入新节点
+        if (previousNode.next) {
+            newNode.next = previousNode.next;
+            previousNode.next.previous = newNode;
+        }
+        previousNode.next = newNode;
+        newNode.previous = previousNode;
+        // 在高层加入新节点, 具体加到多高是随机的, 从第一层(将其视作索引值0)开始建造
+        // 层数非常高是极为罕见的, 因为每次建造层都会导致下一层被建造的概率减半.
+        let level = 0;
+        while (Math.random() < 0.5) {
+            // currentLevel的索引与当前跳跃列表的高度相同, 需要在这之上建立一个新层
+            if (level === this.height) {
+                const newHead = new SkipListNode(null);
+                const newTail = new SkipListNode(null);
+                newHead.next = newTail;
+                newHead.down = this.head;
+                newTail.previous = newHead;
+                newTail.down = this.tail;
+                this.head.up = newHead;
+                this.tail.up = newTail;
+                this.head = newHead;
+                this.tail = newTail;
+                this.height++;
+            }
+            // 从新节点的前一个节点遍历, 直到找到能够通往上层的节点
+            while (!previousNode.up) {
+                // head节点必然会有up, 所以不可能访问进入循环体, 不可能访问`head.previous`
+                previousNode = previousNode.previous;
+            }
+            // 上一层的对应节点
+            previousNode = previousNode.up;
+            // 创建新节点的上层节点
+            const upperNewNode = new SkipListNode(value);
+            if (previousNode.next) {
+                upperNewNode.next = previousNode.next;
+                previousNode.next.previous = upperNewNode;
+            }
+            previousNode.next = upperNewNode;
+            upperNewNode.previous = previousNode;
+            upperNewNode.down = newNode;
+            newNode.up = upperNewNode;
+            newNode = upperNewNode;
+            level++;
+        }
+        this._size++;
+    }
+    findPreviousNode(value) {
+        let currentNode = this.head;
+        while (true) {
+            while (currentNode.next && es2018$e.isntNull(currentNode.next.value)) {
+                const result = this.compare(currentNode.next.value, value);
+                if (result >= 0) {
+                    break;
+                }
+                else {
+                    currentNode = currentNode.next;
+                }
+            }
+            if (currentNode.down) {
+                currentNode = currentNode.down;
+            }
+            else {
+                return currentNode;
+            }
+        }
+    }
+}
+
+class SortedSet {
+    constructor(compare) {
+        this.skipList = new SkipList(compare);
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    *[Symbol.iterator]() {
+        for (const value of this.values()) {
+            yield value;
+        }
+    }
+    values() {
+        return es2018$4.map(this.skipList.elements(), node => node.value);
+    }
+    has(value) {
+        return this.skipList.has(value);
+    }
+    add(value) {
+        this.skipList.add(value);
+    }
+    delete(value) {
+        this.skipList.delete(value);
+    }
+}
+
+export { BadEventError, Box, DynamicTypedArray, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SortedSet, SparseMap, SparseSet, TLRUMap, TrieMap, TypedSparseMap, TypedSparseSet, convertArrayToCons, convertConsToArray };
 //# sourceMappingURL=index.mjs.map