data-structure-typed 2.4.5 → 2.5.1

package/dist/leetcode/singly-linked-list.mjs

@@ -1,754 +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 LinkedListNode = class {
-  static {
-    __name(this, "LinkedListNode");
-  }
-  constructor(value) {
-    this._value = value;
-    this._next = void 0;
-  }
-  _value;
-  get value() {
-    return this._value;
-  }
-  set value(value) {
-    this._value = value;
-  }
-  _next;
-  get next() {
-    return this._next;
-  }
-  set next(value) {
-    this._next = value;
-  }
-};
-var LinearBase = class _LinearBase extends IterableElementBase {
-  static {
-    __name(this, "LinearBase");
-  }
-  constructor(options) {
-    super(options);
-    if (options) {
-      const { maxLen } = options;
-      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
-    }
-  }
-  _maxLen = -1;
-  get maxLen() {
-    return this._maxLen;
-  }
-  indexOf(searchElement, fromIndex = 0) {
-    if (this.length === 0) return -1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    if (fromIndex < 0) fromIndex = 0;
-    for (let i = fromIndex; i < this.length; i++) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  lastIndexOf(searchElement, fromIndex = this.length - 1) {
-    if (this.length === 0) return -1;
-    if (fromIndex >= this.length) fromIndex = this.length - 1;
-    if (fromIndex < 0) fromIndex = this.length + fromIndex;
-    for (let i = fromIndex; i >= 0; i--) {
-      const element = this.at(i);
-      if (element === searchElement) return i;
-    }
-    return -1;
-  }
-  findIndex(predicate, thisArg) {
-    for (let i = 0; i < this.length; i++) {
-      const item = this.at(i);
-      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
-    }
-    return -1;
-  }
-  concat(...items) {
-    const newList = this.clone();
-    for (const item of items) {
-      if (item instanceof _LinearBase) {
-        newList.pushMany(item);
-      } else {
-        newList.push(item);
-      }
-    }
-    return newList;
-  }
-  sort(compareFn) {
-    const arr = this.toArray();
-    arr.sort(compareFn);
-    this.clear();
-    for (const item of arr) this.push(item);
-    return this;
-  }
-  splice(start, deleteCount = 0, ...items) {
-    const removedList = this._createInstance();
-    start = start < 0 ? this.length + start : start;
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
-    for (let i = 0; i < deleteCount; i++) {
-      const removed = this.deleteAt(start);
-      if (removed !== void 0) {
-        removedList.push(removed);
-      }
-    }
-    for (let i = 0; i < items.length; i++) {
-      this.addAt(start + i, items[i]);
-    }
-    return removedList;
-  }
-  join(separator = ",") {
-    return this.toArray().join(separator);
-  }
-  toReversedArray() {
-    const array = [];
-    for (let i = this.length - 1; i >= 0; i--) {
-      array.push(this.at(i));
-    }
-    return array;
-  }
-  reduceRight(callbackfn, initialValue) {
-    let accumulator = initialValue ?? 0;
-    for (let i = this.length - 1; i >= 0; i--) {
-      accumulator = callbackfn(accumulator, this.at(i), i, this);
-    }
-    return accumulator;
-  }
-  slice(start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    const newList = this._createInstance();
-    for (let i = start; i < end; i++) {
-      newList.push(this.at(i));
-    }
-    return newList;
-  }
-  fill(value, start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    if (start < 0) start = 0;
-    if (end > this.length) end = this.length;
-    if (start >= end) return this;
-    for (let i = start; i < end; i++) {
-      this.setAt(i, value);
-    }
-    return this;
-  }
-};
-var LinearLinkedBase = class extends LinearBase {
-  static {
-    __name(this, "LinearLinkedBase");
-  }
-  constructor(options) {
-    super(options);
-    if (options) {
-      const { maxLen } = options;
-      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
-    }
-  }
-  indexOf(searchElement, fromIndex = 0) {
-    const iterator = this._getIterator();
-    let current = iterator.next();
-    let index = 0;
-    while (index < fromIndex) {
-      current = iterator.next();
-      index++;
-    }
-    while (!current.done) {
-      if (current.value === searchElement) return index;
-      current = iterator.next();
-      index++;
-    }
-    return -1;
-  }
-  lastIndexOf(searchElement, fromIndex = this.length - 1) {
-    const iterator = this._getReverseIterator();
-    let current = iterator.next();
-    let index = this.length - 1;
-    while (index > fromIndex) {
-      current = iterator.next();
-      index--;
-    }
-    while (!current.done) {
-      if (current.value === searchElement) return index;
-      current = iterator.next();
-      index--;
-    }
-    return -1;
-  }
-  concat(...items) {
-    const newList = this.clone();
-    for (const item of items) {
-      if (item instanceof LinearBase) {
-        newList.pushMany(item);
-      } else {
-        newList.push(item);
-      }
-    }
-    return newList;
-  }
-  slice(start = 0, end = this.length) {
-    start = start < 0 ? this.length + start : start;
-    end = end < 0 ? this.length + end : end;
-    const newList = this._createInstance();
-    const iterator = this._getIterator();
-    let current = iterator.next();
-    let c = 0;
-    while (c < start) {
-      current = iterator.next();
-      c++;
-    }
-    for (let i = start; i < end; i++) {
-      newList.push(current.value);
-      current = iterator.next();
-    }
-    return newList;
-  }
-  splice(start, deleteCount = 0, ...items) {
-    const removedList = this._createInstance();
-    start = start < 0 ? this.length + start : start;
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, deleteCount);
-    let currentIndex = 0;
-    let currentNode = void 0;
-    let previousNode = void 0;
-    const iterator = this._getNodeIterator();
-    for (const node of iterator) {
-      if (currentIndex === start) {
-        currentNode = node;
-        break;
-      }
-      previousNode = node;
-      currentIndex++;
-    }
-    for (let i = 0; i < deleteCount && currentNode; i++) {
-      removedList.push(currentNode.value);
-      const nextNode = currentNode.next;
-      this.delete(currentNode);
-      currentNode = nextNode;
-    }
-    for (let i = 0; i < items.length; i++) {
-      if (previousNode) {
-        this.addAfter(previousNode, items[i]);
-        previousNode = previousNode.next;
-      } else {
-        this.addAt(0, items[i]);
-        previousNode = this._getNodeIterator().next().value;
-      }
-    }
-    return removedList;
-  }
-  reduceRight(callbackfn, initialValue) {
-    let accumulator = initialValue ?? 0;
-    let index = this.length - 1;
-    for (const item of this._getReverseIterator()) {
-      accumulator = callbackfn(accumulator, item, index--, this);
-    }
-    return accumulator;
-  }
-};
-var SinglyLinkedListNode = class extends LinkedListNode {
-  static {
-    __name(this, "SinglyLinkedListNode");
-  }
-  constructor(value) {
-    super(value);
-    this._value = value;
-    this._next = void 0;
-  }
-  _next;
-  get next() {
-    return this._next;
-  }
-  set next(value) {
-    this._next = value;
-  }
-};
-var SinglyLinkedList = class extends LinearLinkedBase {
-  static {
-    __name(this, "SinglyLinkedList");
-  }
-  _equals = Object.is;
-  constructor(elements = [], options) {
-    super(options);
-    this.pushMany(elements);
-  }
-  _head;
-  get head() {
-    return this._head;
-  }
-  _tail;
-  get tail() {
-    return this._tail;
-  }
-  _length = 0;
-  get length() {
-    return this._length;
-  }
-  get first() {
-    return this.head?.value;
-  }
-  get last() {
-    return this.tail?.value;
-  }
-  static from(data, options) {
-    const list = new this([], options);
-    for (const x of data) list.push(x);
-    return list;
-  }
-  push(elementOrNode) {
-    const newNode = this._ensureNode(elementOrNode);
-    if (!this.head) {
-      this._head = this._tail = newNode;
-    } else {
-      this.tail.next = newNode;
-      this._tail = newNode;
-    }
-    this._length++;
-    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
-    return true;
-  }
-  pop() {
-    if (!this.head) return void 0;
-    if (this.head === this.tail) {
-      const value2 = this.head.value;
-      this._head = void 0;
-      this._tail = void 0;
-      this._length--;
-      return value2;
-    }
-    let current = this.head;
-    while (current.next !== this.tail) current = current.next;
-    const value = this.tail.value;
-    current.next = void 0;
-    this._tail = current;
-    this._length--;
-    return value;
-  }
-  shift() {
-    if (!this.head) return void 0;
-    const removed = this.head;
-    this._head = this.head.next;
-    if (!this._head) this._tail = void 0;
-    this._length--;
-    return removed.value;
-  }
-  unshift(elementOrNode) {
-    const newNode = this._ensureNode(elementOrNode);
-    if (!this.head) {
-      this._head = this._tail = newNode;
-    } else {
-      newNode.next = this.head;
-      this._head = newNode;
-    }
-    this._length++;
-    return true;
-  }
-  pushMany(elements) {
-    const ans = [];
-    for (const el of elements) {
-      if (this.toElementFn) ans.push(this.push(this.toElementFn(el)));
-      else ans.push(this.push(el));
-    }
-    return ans;
-  }
-  unshiftMany(elements) {
-    const ans = [];
-    for (const el of elements) {
-      if (this.toElementFn) ans.push(this.unshift(this.toElementFn(el)));
-      else ans.push(this.unshift(el));
-    }
-    return ans;
-  }
-  search(elementNodeOrPredicate) {
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let current = this.head;
-    while (current) {
-      if (predicate(current)) return current.value;
-      current = current.next;
-    }
-    return void 0;
-  }
-  at(index) {
-    if (index < 0 || index >= this._length) return void 0;
-    let current = this.head;
-    for (let i = 0; i < index; i++) current = current.next;
-    return current.value;
-  }
-  isNode(elementNodeOrPredicate) {
-    return elementNodeOrPredicate instanceof SinglyLinkedListNode;
-  }
-  getNodeAt(index) {
-    if (index < 0 || index >= this._length) return void 0;
-    let current = this.head;
-    for (let i = 0; i < index; i++) current = current.next;
-    return current;
-  }
-  deleteAt(index) {
-    if (index < 0 || index >= this._length) return void 0;
-    if (index === 0) return this.shift();
-    const targetNode = this.getNodeAt(index);
-    const prevNode = this._getPrevNode(targetNode);
-    const value = targetNode.value;
-    prevNode.next = targetNode.next;
-    if (targetNode === this.tail) this._tail = prevNode;
-    this._length--;
-    return value;
-  }
-  delete(elementOrNode) {
-    if (elementOrNode === void 0 || !this.head) return false;
-    const node = this.isNode(elementOrNode) ? elementOrNode : this.getNode(elementOrNode);
-    if (!node) return false;
-    const prevNode = this._getPrevNode(node);
-    if (!prevNode) {
-      this._head = node.next;
-      if (node === this.tail) this._tail = void 0;
-    } else {
-      prevNode.next = node.next;
-      if (node === this.tail) this._tail = prevNode;
-    }
-    this._length--;
-    return true;
-  }
-  addAt(index, newElementOrNode) {
-    if (index < 0 || index > this._length) return false;
-    if (index === 0) return this.unshift(newElementOrNode);
-    if (index === this._length) return this.push(newElementOrNode);
-    const newNode = this._ensureNode(newElementOrNode);
-    const prevNode = this.getNodeAt(index - 1);
-    newNode.next = prevNode.next;
-    prevNode.next = newNode;
-    this._length++;
-    return true;
-  }
-  setAt(index, value) {
-    const node = this.getNodeAt(index);
-    if (!node) return false;
-    node.value = value;
-    return true;
-  }
-  isEmpty() {
-    return this._length === 0;
-  }
-  clear() {
-    this._head = void 0;
-    this._tail = void 0;
-    this._length = 0;
-  }
-  reverse() {
-    if (!this.head || this.head === this.tail) return this;
-    let prev;
-    let current = this.head;
-    let next;
-    while (current) {
-      next = current.next;
-      current.next = prev;
-      prev = current;
-      current = next;
-    }
-    [this._head, this._tail] = [this.tail, this.head];
-    return this;
-  }
-  getNode(elementNodeOrPredicate) {
-    if (elementNodeOrPredicate === void 0) return;
-    if (this.isNode(elementNodeOrPredicate)) return elementNodeOrPredicate;
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let current = this.head;
-    while (current) {
-      if (predicate(current)) return current;
-      current = current.next;
-    }
-    return void 0;
-  }
-  addBefore(existingElementOrNode, newElementOrNode) {
-    const existingNode = this.getNode(existingElementOrNode);
-    if (!existingNode) return false;
-    const prevNode = this._getPrevNode(existingNode);
-    const newNode = this._ensureNode(newElementOrNode);
-    if (!prevNode) {
-      newNode.next = this._head;
-      this._head = newNode;
-      if (!this._tail) this._tail = newNode;
-      this._length++;
-    } else {
-      prevNode.next = newNode;
-      newNode.next = existingNode;
-      this._length++;
-    }
-    return true;
-  }
-  addAfter(existingElementOrNode, newElementOrNode) {
-    const existingNode = this.getNode(existingElementOrNode);
-    if (!existingNode) return false;
-    const newNode = this._ensureNode(newElementOrNode);
-    newNode.next = existingNode.next;
-    existingNode.next = newNode;
-    if (existingNode === this.tail) this._tail = newNode;
-    this._length++;
-    return true;
-  }
-  splice(start, deleteCount = 0, ...items) {
-    start = Math.max(0, Math.min(start, this.length));
-    deleteCount = Math.max(0, deleteCount);
-    const removedList = this._createInstance();
-    const prevNode = start === 0 ? void 0 : this.getNodeAt(start - 1);
-    let cur = prevNode ? prevNode.next : this.head;
-    let removedCount = 0;
-    while (removedCount < deleteCount && cur) {
-      removedList.push(cur.value);
-      cur = cur.next;
-      removedCount++;
-    }
-    const afterNode = cur;
-    if (prevNode) {
-      prevNode.next = afterNode;
-    } else {
-      this._head = afterNode;
-    }
-    if (!afterNode) this._tail = prevNode;
-    if (items.length > 0) {
-      let firstInserted;
-      let lastInserted;
-      for (const it of items) {
-        const node = this._ensureNode(it);
-        if (!firstInserted) firstInserted = node;
-        if (lastInserted) lastInserted.next = node;
-        lastInserted = node;
-      }
-      if (prevNode) prevNode.next = firstInserted;
-      else this._head = firstInserted;
-      lastInserted.next = afterNode;
-      if (!afterNode) this._tail = lastInserted;
-    }
-    this._length += items.length - removedCount;
-    if (this._length === 0) {
-      this._head = void 0;
-      this._tail = void 0;
-    }
-    return removedList;
-  }
-  countOccurrences(elementOrNode) {
-    const predicate = elementOrPredicate(elementOrNode, this._equals);
-    let count = 0;
-    let current = this.head;
-    while (current) {
-      if (predicate(current)) count++;
-      current = current.next;
-    }
-    return count;
-  }
-  setEquality(equals) {
-    this._equals = equals;
-    return this;
-  }
-  deleteWhere(predicate) {
-    let prev;
-    let current = this.head;
-    let i = 0;
-    while (current) {
-      if (predicate(current.value, i++, this)) {
-        if (!prev) {
-          this._head = current.next;
-          if (current === this._tail) this._tail = void 0;
-        } else {
-          prev.next = current.next;
-          if (current === this._tail) this._tail = prev;
-        }
-        this._length--;
-        return true;
-      }
-      prev = current;
-      current = current.next;
-    }
-    return false;
-  }
-  clone() {
-    const out = this._createInstance();
-    for (const v of this) out.push(v);
-    return out;
-  }
-  filter(callback, thisArg) {
-    const out = this._createInstance();
-    let index = 0;
-    for (const value of this) if (callback.call(thisArg, value, index++, this)) out.push(value);
-    return out;
-  }
-  mapSame(callback, thisArg) {
-    const out = this._createInstance();
-    let index = 0;
-    for (const value of this) {
-      const mv = thisArg === void 0 ? callback(value, index++, this) : callback.call(thisArg, value, index++, this);
-      out.push(mv);
-    }
-    return out;
-  }
-  map(callback, options, thisArg) {
-    const out = this._createLike([], { ...options ?? {}, maxLen: this._maxLen });
-    let index = 0;
-    for (const value of this) out.push(callback.call(thisArg, value, index++, this));
-    return out;
-  }
-  createNode(value) {
-    return new SinglyLinkedListNode(value);
-  }
-  _isPredicate(elementNodeOrPredicate) {
-    return typeof elementNodeOrPredicate === "function";
-  }
-  _ensureNode(elementOrNode) {
-    if (this.isNode(elementOrNode)) return elementOrNode;
-    return this.createNode(elementOrNode);
-  }
-  _ensurePredicate(elementNodeOrPredicate) {
-    if (this.isNode(elementNodeOrPredicate)) return (node) => node === elementNodeOrPredicate;
-    if (this._isPredicate(elementNodeOrPredicate)) return elementNodeOrPredicate;
-    const value = elementNodeOrPredicate;
-    return (node) => this._equals(node.value, value);
-  }
-  _getPrevNode(node) {
-    if (!this.head || this.head === node) return void 0;
-    let current = this.head;
-    while (current.next && current.next !== node) current = current.next;
-    return current.next === node ? current : void 0;
-  }
-  *_getIterator() {
-    let current = this.head;
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
-  }
-  *_getReverseIterator() {
-    const reversedArr = [...this].reverse();
-    for (const item of reversedArr) yield item;
-  }
-  *_getNodeIterator() {
-    let current = this.head;
-    while (current) {
-      yield current;
-      current = current.next;
-    }
-  }
-  _createInstance(options) {
-    const Ctor = this.constructor;
-    return new Ctor([], options);
-  }
-  _createLike(elements = [], options) {
-    const Ctor = this.constructor;
-    return new Ctor(elements, options);
-  }
-  _spawnLike(options) {
-    return this._createLike([], options);
-  }
-};
-function elementOrPredicate(input, equals) {
-  if (input instanceof SinglyLinkedListNode) return (node) => node === input;
-  if (typeof input === "function") return input;
-  const value = input;
-  return (node) => equals(node.value, value);
-}
-__name(elementOrPredicate, "elementOrPredicate");
-export {
-  SinglyLinkedList,
-  SinglyLinkedListNode
-};