data-structure-typed 2.4.5 → 2.5.1

package/dist/leetcode/priority-queue.mjs

@@ -1,363 +0,0 @@
-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);
-  }
-};
-export {
-  PriorityQueue
-};