data-structure-typed 2.2.7 → 2.3.0

package/dist/leetcode/max-priority-queue.mjs

@@ -0,0 +1,383 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
+  constructor(options) {
+    if (options) {
+      const { toElementFn } = options;
+      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+    }
+  }
+  _toElementFn;
+  get toElementFn() {
+    return this._toElementFn;
+  }
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  *values() {
+    for (const item of this) yield item;
+  }
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (!predicate(item, index++, this)) return false;
+      } else {
+        const fn = predicate;
+        if (!fn.call(thisArg, item, index++, this)) return false;
+      }
+    }
+    return true;
+  }
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return true;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return true;
+      }
+    }
+    return false;
+  }
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        callbackfn(item, index++, this);
+      } else {
+        const fn = callbackfn;
+        fn.call(thisArg, item, index++, this);
+      }
+    }
+  }
+  find(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return item;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return item;
+      }
+    }
+    return;
+  }
+  has(element) {
+    for (const ele of this) if (ele === element) return true;
+    return false;
+  }
+  reduce(callbackfn, initialValue) {
+    let index = 0;
+    const iter = this[Symbol.iterator]();
+    let acc;
+    if (arguments.length >= 2) {
+      acc = initialValue;
+    } else {
+      const first = iter.next();
+      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      acc = first.value;
+      index = 1;
+    }
+    for (const value of iter) {
+      acc = callbackfn(acc, value, index++, this);
+    }
+    return acc;
+  }
+  toArray() {
+    return [...this];
+  }
+  toVisual() {
+    return [...this];
+  }
+  print() {
+    console.log(this.toVisual());
+  }
+};
+var Heap = class _Heap extends IterableElementBase {
+  static {
+    __name(this, "Heap");
+  }
+  _equals = Object.is;
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { comparator } = options;
+      if (comparator) this._comparator = comparator;
+    }
+    this.addMany(elements);
+  }
+  _elements = [];
+  get elements() {
+    return this._elements;
+  }
+  get size() {
+    return this.elements.length;
+  }
+  get leaf() {
+    return this.elements[this.size - 1] ?? void 0;
+  }
+  static from(elements, options) {
+    return new this(elements, options);
+  }
+  static heapify(elements, options) {
+    return new _Heap(elements, options);
+  }
+  add(element) {
+    this._elements.push(element);
+    return this._bubbleUp(this.elements.length - 1);
+  }
+  addMany(elements) {
+    const flags = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        const ok = this.add(this.toElementFn(el));
+        flags.push(ok);
+      } else {
+        const ok = this.add(el);
+        flags.push(ok);
+      }
+    }
+    return flags;
+  }
+  poll() {
+    if (this.elements.length === 0) return;
+    const value = this.elements[0];
+    const last = this.elements.pop();
+    if (this.elements.length) {
+      this.elements[0] = last;
+      this._sinkDown(0, this.elements.length >> 1);
+    }
+    return value;
+  }
+  peek() {
+    return this.elements[0];
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  clear() {
+    this._elements = [];
+  }
+  refill(elements) {
+    this._elements = Array.from(elements);
+    return this.fix();
+  }
+  has(element) {
+    for (const el of this.elements) if (this._equals(el, element)) return true;
+    return false;
+  }
+  delete(element) {
+    let index = -1;
+    for (let i = 0; i < this.elements.length; i++) {
+      if (this._equals(this.elements[i], element)) {
+        index = i;
+        break;
+      }
+    }
+    if (index < 0) return false;
+    if (index === 0) {
+      this.poll();
+    } else if (index === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(index, 1, this.elements.pop());
+      this._bubbleUp(index);
+      this._sinkDown(index, this.elements.length >> 1);
+    }
+    return true;
+  }
+  deleteBy(predicate) {
+    let idx = -1;
+    for (let i = 0; i < this.elements.length; i++) {
+      if (predicate(this.elements[i], i, this)) {
+        idx = i;
+        break;
+      }
+    }
+    if (idx < 0) return false;
+    if (idx === 0) {
+      this.poll();
+    } else if (idx === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(idx, 1, this.elements.pop());
+      this._bubbleUp(idx);
+      this._sinkDown(idx, this.elements.length >> 1);
+    }
+    return true;
+  }
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  dfs(order = "PRE") {
+    const result = [];
+    const _dfs =  __name((index) => {
+      const left = 2 * index + 1, right = left + 1;
+      if (index < this.size) {
+        if (order === "IN") {
+          _dfs(left);
+          result.push(this.elements[index]);
+          _dfs(right);
+        } else if (order === "PRE") {
+          result.push(this.elements[index]);
+          _dfs(left);
+          _dfs(right);
+        } else if (order === "POST") {
+          _dfs(left);
+          _dfs(right);
+          result.push(this.elements[index]);
+        }
+      }
+    }, "_dfs");
+    _dfs(0);
+    return result;
+  }
+  fix() {
+    const results = [];
+    for (let i = Math.floor(this.size / 2) - 1; i >= 0; i--) {
+      results.push(this._sinkDown(i, this.elements.length >> 1));
+    }
+    return results;
+  }
+  sort() {
+    const visited = [];
+    const cloned = this._createInstance();
+    for (const x of this.elements) cloned.add(x);
+    while (!cloned.isEmpty()) {
+      const top = cloned.poll();
+      if (top !== void 0) visited.push(top);
+    }
+    return visited;
+  }
+  clone() {
+    const next = this._createInstance();
+    for (const x of this.elements) next.add(x);
+    return next;
+  }
+  filter(callback, thisArg) {
+    const out = this._createInstance();
+    let i = 0;
+    for (const x of this) {
+      if (thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this)) {
+        out.add(x);
+      } else {
+        i++;
+      }
+    }
+    return out;
+  }
+  map(callback, options, thisArg) {
+    const { comparator, toElementFn, ...rest } = options ?? {};
+    if (!comparator) throw new TypeError("Heap.map requires options.comparator for EM");
+    const out = this._createLike([], { ...rest, comparator, toElementFn });
+    let i = 0;
+    for (const x of this) {
+      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+      out.add(v);
+    }
+    return out;
+  }
+  mapSame(callback, thisArg) {
+    const out = this._createInstance();
+    let i = 0;
+    for (const x of this) {
+      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+      out.add(v);
+    }
+    return out;
+  }
+  _DEFAULT_COMPARATOR =  __name((a, b) => {
+    if (typeof a === "object" || typeof b === "object") {
+      throw TypeError("When comparing object types, define a custom comparator in options.");
+    }
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  }, "_DEFAULT_COMPARATOR");
+  _comparator = this._DEFAULT_COMPARATOR;
+  get comparator() {
+    return this._comparator;
+  }
+  *_getIterator() {
+    for (const element of this.elements) yield element;
+  }
+  _bubbleUp(index) {
+    const element = this.elements[index];
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      const parentItem = this.elements[parent];
+      if (this.comparator(parentItem, element) <= 0) break;
+      this.elements[index] = parentItem;
+      index = parent;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+  _sinkDown(index, halfLength) {
+    const element = this.elements[index];
+    while (index < halfLength) {
+      let left = index << 1 | 1;
+      const right = left + 1;
+      let minItem = this.elements[left];
+      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
+        left = right;
+        minItem = this.elements[right];
+      }
+      if (this.comparator(minItem, element) >= 0) break;
+      this.elements[index] = minItem;
+      index = left;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options ?? {} });
+    return next;
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  _spawnLike(options) {
+    return this._createLike([], options);
+  }
+};
+var PriorityQueue = class extends Heap {
+  static {
+    __name(this, "PriorityQueue");
+  }
+  constructor(elements = [], options) {
+    super(elements, options);
+  }
+};
+var MaxPriorityQueue = class extends PriorityQueue {
+  static {
+    __name(this, "MaxPriorityQueue");
+  }
+  constructor(elements = [], options) {
+    super(elements, {
+      comparator:  __name((a, b) => {
+        if (typeof a === "object" || typeof b === "object") {
+          throw TypeError(
+            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+          );
+        }
+        if (a < b) return 1;
+        if (a > b) return -1;
+        return 0;
+      }, "comparator"),
+      ...options
+    });
+  }
+};
+export {
+  MaxPriorityQueue
+};