@blackglory/structures 0.8.0 → 0.10.1

package/dist/es2018/index.umd.js

@@ -9647,6 +9647,227 @@
         }
     }
 
+    class SparseSet {
+        constructor(array = []) {
+            this.indexToValue = [];
+            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;
+        }
+        [Symbol.iterator]() {
+            return this.indexToValue[Symbol.iterator]();
+        }
+        values() {
+            return this.indexToValue[Symbol.iterator]();
+        }
+        has(value) {
+            // 跟一般的实现不同, 不需要访问values数组.
+            return value in this.valueToIndex;
+        }
+        add(value) {
+            if (!this.has(value)) {
+                const index = this.indexToValue.length;
+                this.indexToValue.push(value);
+                this.valueToIndex[value] = index;
+            }
+        }
+        delete(value) {
+            if (this.has(value)) {
+                const lastValue = this.indexToValue.pop();
+                if (value === lastValue) {
+                    delete this.valueToIndex[value];
+                }
+                else {
+                    const index = this.valueToIndex[value];
+                    this.indexToValue[index] = lastValue;
+                    this.valueToIndex[lastValue] = index;
+                    // 跟一般的实现不同, 直接删除值的索引.
+                    delete this.valueToIndex[value];
+                }
+            }
+        }
+    }
+
+    class SparseMap {
+        constructor() {
+            this.keyToIndex = [];
+            this.indexToKey = [];
+            this.indexToValue = [];
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        *entries() {
+            for (let i = 0; i < this.indexToKey.length; i++) {
+                yield [this.indexToKey[i], this.indexToValue[i]];
+            }
+        }
+        keys() {
+            return this.indexToKey.values();
+        }
+        values() {
+            return this.indexToValue.values();
+        }
+        has(key) {
+            // 跟一般的稀疏集实现不同, 不需要访问values数组.
+            return key in this.keyToIndex;
+        }
+        get(key) {
+            if (this.has(key)) {
+                const index = this.keyToIndex[key];
+                return this.indexToValue[index];
+            }
+            else {
+                return undefined;
+            }
+        }
+        set(key, value) {
+            if (this.has(key)) {
+                const index = this.keyToIndex[key];
+                this.indexToValue[index] = value;
+            }
+            else {
+                const index = this.indexToKey.length;
+                this.indexToKey.push(key);
+                this.indexToValue.push(value);
+                this.keyToIndex[key] = index;
+            }
+        }
+        delete(key) {
+            if (this.has(key)) {
+                const lastKey = this.indexToKey.pop();
+                const lastValue = this.indexToValue.pop();
+                if (key === lastKey) {
+                    delete this.keyToIndex[key];
+                }
+                else {
+                    const index = this.keyToIndex[key];
+                    this.indexToKey[index] = lastKey;
+                    this.indexToValue[index] = lastValue;
+                    this.keyToIndex[key] = index;
+                    delete this.keyToIndex[key];
+                }
+            }
+        }
+    }
+
+    class TypedSparseMap {
+        constructor(array) {
+            this.keyToIndex = [];
+            this.indexToKey = [];
+            es2018$d.assert(array.length === 0, 'array should be empty');
+            this.indexToValue = array;
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        *entries() {
+            for (let i = 0; i < this.indexToKey.length; i++) {
+                yield [
+                    this.indexToKey[i],
+                    this.indexToValue.internalTypedArray[i]
+                ];
+            }
+        }
+        keys() {
+            return this.indexToKey.values();
+        }
+        *values() {
+            for (let i = 0; i < this.indexToKey.length; i++) {
+                yield this.indexToValue.internalTypedArray[i];
+            }
+        }
+        has(key) {
+            const index = this.keyToIndex[key];
+            return this.indexToKey[index] === key;
+        }
+        get(key) {
+            const index = this.keyToIndex[key];
+            if (this.indexToKey[index] === key) {
+                return this.indexToValue.internalTypedArray[index];
+            }
+            else {
+                return undefined;
+            }
+        }
+        set(key, value) {
+            const index = this.keyToIndex[key];
+            if (this.indexToKey[index] === key) {
+                this.indexToValue.internalTypedArray[index] = value;
+            }
+            else {
+                const index = this.indexToKey.length;
+                this.indexToKey.push(key);
+                this.indexToValue.push(value);
+                this.keyToIndex[key] = index;
+            }
+        }
+        delete(key) {
+            const index = this.keyToIndex[key];
+            if (this.indexToKey[index] === key) {
+                const lastKey = this.indexToKey.pop();
+                const lastValue = this.indexToValue.pop();
+                if (key !== lastKey) {
+                    this.indexToKey[index] = lastKey;
+                    this.indexToValue.internalTypedArray[index] = lastValue;
+                    this.keyToIndex[lastKey] = index;
+                }
+            }
+        }
+    }
+
+    class TypedSparseSet {
+        constructor(array) {
+            const valueToIndex = [];
+            if (array.length > 0) {
+                for (const [index, value] of array.internalTypedArray.entries()) {
+                    valueToIndex[value] = index;
+                }
+            }
+            this.indexToValue = array;
+            this.valueToIndex = valueToIndex;
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        [Symbol.iterator]() {
+            return this.values();
+        }
+        *values() {
+            for (let i = 0; i < this.indexToValue.length; i++) {
+                yield this.indexToValue.internalTypedArray[i];
+            }
+        }
+        has(value) {
+            const index = this.valueToIndex[value];
+            return this.indexToValue.internalTypedArray[index] === value;
+        }
+        add(value) {
+            if (!this.has(value)) {
+                const index = this.indexToValue.length;
+                this.indexToValue.push(value);
+                this.valueToIndex[value] = index;
+            }
+        }
+        delete(value) {
+            const index = this.valueToIndex[value];
+            if (this.indexToValue.internalTypedArray[index] === value) {
+                const lastValue = this.indexToValue.pop();
+                if (value !== lastValue) {
+                    this.indexToValue.internalTypedArray[index] = lastValue;
+                    this.valueToIndex[lastValue] = index;
+                }
+            }
+        }
+    }
+
     // 相关提案: https://github.com/tc39/proposal-resizablearraybuffer
     class DynamicTypedArray {
         constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
@@ -9654,7 +9875,7 @@
             this._length = 0;
             es2018$d.assert(Number.isInteger(capacity), 'capacity must be an integer');
             es2018$d.assert(capacity >= 0, 'capacity must be greater than or equal to 0');
-            es2018$d.assert(growthFactor > 1, 'growthFactory must be greater than or equal to 1');
+            es2018$d.assert(growthFactor >= 1, 'growthFactory must be greater than or equal to 1');
             this.array = new typedArrayConstructor(capacity);
             this.growthFactor = growthFactor;
         }
@@ -9733,133 +9954,231 @@
         }
     }
     function computeNewCapacity(oldCapacity, targetLength, growthFactor) {
-        if (oldCapacity === targetLength) {
+        if (growthFactor === 1) {
             return targetLength;
         }
-        else if (oldCapacity < targetLength) {
-            // 增加容量以适配targetLength
-            let newCapacity = Math.max(oldCapacity, 1);
-            while (newCapacity < targetLength) {
-                newCapacity *= growthFactor;
-            }
-            return Math.floor(newCapacity);
-        }
         else {
-            // 尝试减少容量以适配targetLength
-            // `targetLength = 0`是特殊情况,
-            // 此时无论怎么将oldCapacity除以growthFactory几次, 都不可能得到比targetLength小的结果.
-            if (targetLength === 0) {
-                return 0;
+            if (oldCapacity === targetLength) {
+                return targetLength;
+            }
+            else if (oldCapacity < targetLength) {
+                // 增加容量以适配targetLength
+                let newCapacity = Math.max(oldCapacity, 1);
+                while (newCapacity < targetLength) {
+                    newCapacity *= growthFactor;
+                }
+                return Math.floor(newCapacity);
             }
             else {
-                let newCapacity = oldCapacity;
-                while (true) {
-                    const temp = newCapacity / growthFactor;
-                    if (temp < targetLength) {
-                        break;
-                    }
-                    else {
-                        newCapacity = temp;
+                // 尝试减少容量以适配targetLength
+                // `targetLength = 0`是特殊情况,
+                // 此时无论怎么将oldCapacity除以growthFactory几次, 都不可能得到比targetLength小的结果.
+                if (targetLength === 0) {
+                    return 0;
+                }
+                else {
+                    let newCapacity = oldCapacity;
+                    while (true) {
+                        const temp = newCapacity / growthFactor;
+                        if (temp < targetLength) {
+                            break;
+                        }
+                        else {
+                            newCapacity = temp;
+                        }
                     }
+                    return Math.floor(newCapacity);
                 }
-                return Math.floor(newCapacity);
             }
         }
     }
 
-    class SparseSet {
-        constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
-            this.indexToValue = new DynamicTypedArray(typedArrayConstructor, { capacity, growthFactor });
-            this.valueToIndex = new DynamicTypedArray(Uint32Array, { capacity, growthFactor });
+    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;
         }
-        get [Symbol.toStringTag]() {
-            return this.constructor.name;
+        *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;
+            }
         }
-        [Symbol.iterator]() {
-            return this.indexToValue.internalTypedArray[Symbol.iterator]();
+        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) {
-            const index = this.valueToIndex.internalTypedArray[value];
-            return this.indexToValue.internalTypedArray[index] === value;
+            return es2018$e.isntNull(this.findNode(value));
         }
-        add(value) {
-            if (!this.has(value)) {
-                const index = this.indexToValue.length;
-                this.indexToValue.push(value);
-                this.valueToIndex.set(value, index);
+        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;
+                }
             }
         }
-        delete(value) {
-            const index = this.valueToIndex.internalTypedArray[value];
-            if (this.indexToValue.internalTypedArray[index] === value) {
-                const lastValue = this.indexToValue.pop();
-                if (value !== lastValue) {
-                    this.indexToValue.internalTypedArray[index] = lastValue;
-                    this.valueToIndex.internalTypedArray[lastValue] = index;
+        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 SparseMap {
-        constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
-            this.indexToValue = new DynamicTypedArray(typedArrayConstructor, { capacity, growthFactor });
-            this.keyToIndex = new DynamicTypedArray(Uint32Array, { capacity, growthFactor });
-            this.indexToKey = new DynamicTypedArray(Uint32Array, { capacity, growthFactor });
+    class SortedSet {
+        constructor(compare) {
+            this.skipList = new SkipList(compare);
         }
         get [Symbol.toStringTag]() {
             return this.constructor.name;
         }
-        *entries() {
-            for (let i = 0; i < this.indexToKey.length; i++) {
-                yield [
-                    this.indexToKey.internalTypedArray[i],
-                    this.indexToValue.internalTypedArray[i]
-                ];
+        *[Symbol.iterator]() {
+            for (const value of this.values()) {
+                yield value;
             }
         }
-        keys() {
-            return this.indexToKey.internalTypedArray.values();
-        }
         values() {
-            return this.indexToValue.internalTypedArray.values();
+            return es2018$4.map(this.skipList.elements(), node => node.value);
         }
-        has(key) {
-            const index = this.keyToIndex.internalTypedArray[key];
-            return this.indexToKey.internalTypedArray[index] === key;
-        }
-        get(key) {
-            const index = this.keyToIndex.internalTypedArray[key];
-            if (this.indexToKey.internalTypedArray[index] === key) {
-                return this.indexToValue.internalTypedArray[index];
-            }
-            else {
-                return undefined;
-            }
+        has(value) {
+            return this.skipList.has(value);
         }
-        set(key, value) {
-            const index = this.keyToIndex.internalTypedArray[key];
-            if (this.indexToKey.internalTypedArray[index] === key) {
-                this.indexToValue.internalTypedArray[index] = value;
-            }
-            else {
-                const index = this.indexToKey.length;
-                this.indexToKey.push(key);
-                this.indexToValue.push(value);
-                this.keyToIndex.set(key, index);
-            }
+        add(value) {
+            this.skipList.add(value);
         }
-        delete(key) {
-            const index = this.keyToIndex.internalTypedArray[key];
-            if (this.indexToKey.internalTypedArray[index] === key) {
-                const lastKey = this.indexToKey.pop();
-                const lastValue = this.indexToValue.pop();
-                if (key !== lastKey) {
-                    this.indexToKey.internalTypedArray[index] = lastKey;
-                    this.indexToValue.internalTypedArray[index] = lastValue;
-                    this.keyToIndex.internalTypedArray[lastKey] = index;
-                }
-            }
+        delete(value) {
+            this.skipList.delete(value);
         }
     }
 
@@ -9874,10 +10193,13 @@
     exports.LRUMap = LRUMap;
     exports.ObservableFiniteStateMachine = ObservableFiniteStateMachine;
     exports.Queue = Queue;
+    exports.SortedSet = SortedSet;
     exports.SparseMap = SparseMap;
     exports.SparseSet = SparseSet;
     exports.TLRUMap = TLRUMap;
     exports.TrieMap = TrieMap;
+    exports.TypedSparseMap = TypedSparseMap;
+    exports.TypedSparseSet = TypedSparseSet;
     exports.convertArrayToCons = convertArrayToCons;
     exports.convertConsToArray = convertConsToArray;