list-toolkit 1.0.1

package/src/MinHeap.js

@@ -0,0 +1,283 @@
+'use strict';
+
+import {copyOptions} from './utils.js';
+
+// the following functions are inlined:
+
+// const left = i => (i << 1) + 1;
+// const right = i => (i + 1) << 1;
+// const parent = i => (i - 1) >> 1;
+
+const defaultLess = (a, b) => a < b;
+const defaultEqual = (a, b) => a === b;
+
+const up = (array, i, less = defaultLess) => {
+  for (let p = (i - 1) >> 1; i > 0; i = p, p = (i - 1) >> 1) {
+    const iValue = array[i],
+      pValue = array[p];
+    if (!less(iValue, pValue)) break;
+    array[i] = pValue;
+    array[p] = iValue;
+  }
+  return array;
+};
+
+const down = (array, i, less = defaultLess, n = array.length) => {
+  for (;;) {
+    const l = (i << 1) + 1;
+    if (l >= n) break;
+    let c = l,
+      cValue = array[c];
+    const r = c + 1;
+    if (r < n) {
+      const rValue = array[r];
+      if (less(rValue, cValue)) {
+        c = r;
+        cValue = rValue;
+      }
+    }
+    const iValue = array[i];
+    if (!less(cValue, iValue)) break;
+    array[i] = cValue;
+    array[c] = iValue;
+    i = c;
+  }
+  return array;
+};
+
+class MinHeap {
+  constructor(options, ...args) {
+    copyOptions(this, MinHeap.defaults, options);
+    this.array = [];
+    this.merge(...args);
+  }
+
+  get length() {
+    return this.array.length;
+  }
+
+  get isEmpty() {
+    return !this.array.length;
+  }
+
+  get top() {
+    return this.array[0];
+  }
+
+  clear() {
+    this.array = [];
+    return this;
+  }
+
+  pop() {
+    // return MinHeap.pop(this.array, this.less); // inlined
+    switch (this.array.length) {
+      case 0:
+        return;
+      case 1:
+        return this.array.pop();
+    }
+    const top = this.array[0];
+    this.array[0] = this.array.pop();
+    // down(this.array, 0, this.less); // inlined
+    const n = this.array.length;
+    for (let i = 0; ; ) {
+      const l = (i << 1) + 1;
+      if (l >= n) break;
+      let c = l,
+        cValue = this.array[c];
+      const r = c + 1;
+      if (r < n) {
+        const rValue = this.array[r];
+        if (this.less(rValue, cValue)) {
+          c = r;
+          cValue = rValue;
+        }
+      }
+      const iValue = this.array[i];
+      if (!this.less(cValue, iValue)) break;
+      this.array[i] = cValue;
+      this.array[c] = iValue;
+      i = c;
+    }
+    return top;
+  }
+
+  push(value) {
+    // MinHeap.push(this.array, value, this.less); // inlined
+    let i = this.array.length;
+    this.array.push(value);
+    // up(this.array, i, this.less); // inlined
+    for (let p = (i - 1) >> 1; i > 0; i = p, p = (i - 1) >> 1) {
+      const iValue = this.array[i],
+        pValue = this.array[p];
+      if (!this.less(iValue, pValue)) break;
+      this.array[i] = pValue;
+      this.array[p] = iValue;
+    }
+    return this;
+  }
+
+  pushPop(value) {
+    // return MinHeap.pushPop(this.array, value, this.less); // inlined
+    if (!this.array.length || this.less(value, this.array[0])) return value;
+    const top = this.array[0];
+    this.array[0] = value;
+    // down(this.array, 0, this.less); // inlined
+    const n = this.array.length;
+    for (let i = 0; ; ) {
+      const l = (i << 1) + 1;
+      if (l >= n) break;
+      let c = l,
+        cValue = this.array[c];
+      const r = c + 1;
+      if (r < n) {
+        const rValue = this.array[r];
+        if (this.less(rValue, cValue)) {
+          c = r;
+          cValue = rValue;
+        }
+      }
+      const iValue = this.array[i];
+      if (!this.less(cValue, iValue)) break;
+      this.array[i] = cValue;
+      this.array[c] = iValue;
+      i = c;
+    }
+    return top;
+  }
+
+  replaceTop(value) {
+    // return MinHeap.replaceTop(this.array, value, this.less); // inlined
+    const top = this.array[0];
+    this.array[0] = value;
+    // down(this.array, 0, this.less); // inlined
+    const n = this.array.length;
+    for (let i = 0; ; ) {
+      const l = (i << 1) + 1;
+      if (l >= n) break;
+      let c = l,
+        cValue = this.array[c];
+      const r = c + 1;
+      if (r < n) {
+        const rValue = this.array[r];
+        if (this.less(rValue, cValue)) {
+          c = r;
+          cValue = rValue;
+        }
+      }
+      const iValue = this.array[i];
+      if (!this.less(cValue, iValue)) break;
+      this.array[i] = cValue;
+      this.array[c] = iValue;
+      i = c;
+    }
+    return top;
+  }
+
+  releaseSorted() {
+    MinHeap.sort(this.array, this.less);
+    const array = this.array;
+    this.array = [];
+    return array;
+  }
+
+  merge(...args) {
+    if (!args.length) return this;
+    this.array = MinHeap.build(
+      this.array.concat(
+        ...args.map(item => {
+          if (item instanceof MinHeap) return item.array;
+          if (!item) return [];
+          return item;
+        })
+      ),
+      this.less
+    );
+    return this;
+  }
+
+  make(...args) {
+    return new MinHeap(this, ...args);
+  }
+
+  clone() {
+    const heap = new MinHeap(this);
+    heap.array = this.array.slice(0);
+    return heap;
+  }
+
+  static build(array, less = MinHeap.defaults.less) {
+    if (array.length <= 1) return array;
+    for (let n = array.length, j = (n >> 1) - 1; j >= 0; --j) {
+      // down(array, j, less, n); // inlined
+      for (let i = j; ; ) {
+        const l = (i << 1) + 1;
+        if (l >= n) break;
+        let c = l,
+          cValue = array[c];
+        const r = c + 1;
+        if (r < n) {
+          const rValue = array[r];
+          if (less(rValue, cValue)) {
+            c = r;
+            cValue = rValue;
+          }
+        }
+        const iValue = array[i];
+        if (!less(cValue, iValue)) break;
+        array[i] = cValue;
+        array[c] = iValue;
+        i = c;
+      }
+    }
+    return array;
+  }
+
+  static pop(heapArray, less = MinHeap.defaults.less) {
+    switch (heapArray.length) {
+      case 0:
+        return;
+      case 1:
+        return heapArray.pop();
+    }
+    const top = heapArray[0];
+    heapArray[0] = heapArray.pop();
+    down(heapArray, 0, less);
+    return top;
+  }
+
+  static push(heapArray, item, less = MinHeap.defaults.less) {
+    const i = heapArray.length;
+    heapArray.push(item);
+    return up(heapArray, i, less);
+  }
+
+  static pushPop(heapArray, item, less = MinHeap.defaults.less) {
+    if (!heapArray.length || less(item, heapArray[0])) return item;
+    const top = heapArray[0];
+    heapArray[0] = item;
+    down(heapArray, 0, less);
+    return top;
+  }
+
+  static replaceTop(heapArray, item, less = MinHeap.defaults.less) {
+    const top = heapArray[0];
+    heapArray[0] = item;
+    down(heapArray, 0, less);
+    return top;
+  }
+
+  static sort(heapArray, less = MinHeap.defaults.less) {
+    if (heapArray.length <= 1) return heapArray;
+    for (let n = heapArray.length - 1; n; --n) {
+      [heapArray[0], heapArray[n]] = [heapArray[n], heapArray[0]];
+      down(heapArray, 0, less, n);
+    }
+    return heapArray;
+  }
+}
+
+MinHeap.defaults = {less: defaultLess, equal: defaultEqual};
+
+export default MinHeap;

package/src/SList.js

@@ -0,0 +1,329 @@
+'use strict';
+
+class SListNode {
+  constructor() {
+    this.next = this;
+  }
+}
+
+const pop = prev => {
+  const node = prev.next;
+  prev.next = node.next;
+  node.next = node;
+  return {node, list: prev};
+};
+
+const extract = (prevFrom, nodeTo) => {
+  const node = prevFrom.next;
+  if (prevFrom === nodeTo) return {prev: prevFrom, node};
+  prevFrom.next = nodeTo.next;
+  nodeTo.next = node;
+  return {prev: nodeTo, node};
+};
+
+const splice = (prev1, {prev, node}) => {
+  prev.next = prev1.next;
+  prev1.next = node;
+  return prev1;
+};
+
+const getPrevPrev = (list, node) => {
+  let prev = list,
+    current = prev.next;
+  while (current.next !== list) {
+    if (node && current.next === node) return prev;
+    prev = current;
+    current = prev.next;
+  }
+  if (node) {
+    if (list.next === node) return current;
+    throw new Error('node does not belong to the list');
+  }
+  return prev;
+};
+
+const getPrev = (list, node) => {
+  return getPrevPrev(list, node).next;
+};
+
+class SListValueNode extends SListNode {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+
+  addAfter(value) {
+    const node = new SListValueNode(value);
+    splice(this, {prev: node, node});
+    return this;
+  }
+
+  insertAfter(list) {
+    const node = getPrev(pop(list).list);
+    splice(this, {prev: node, node});
+    return this;
+  }
+}
+
+class SList extends SListNode {
+  get isEmpty() {
+    return this.next === this;
+  }
+
+  get front() {
+    return this.next;
+  }
+
+  getBack() {
+    return getPrev(this);
+  }
+
+  getLength() {
+    let n = 0;
+    for (let p = this.next; p !== this; ++n, p = p.next);
+    return n;
+  }
+
+  getPtr() {
+    return new SList.SListPtr(this);
+  }
+
+  popFront() {
+    if (this.next !== this) {
+      return pop(this).node.value;
+    }
+  }
+
+  popBack() {
+    if (this.next !== this) {
+      const prevLast = getPrevPrev(this);
+      return pop(prevLast).node.value;
+    }
+  }
+
+  pushFront(value) {
+    const node = new SListValueNode(value);
+    splice(this, {prev: node, node});
+    return this;
+  }
+
+  pushBack(value) {
+    const node = new SListValueNode(value),
+      last = getPrev(this);
+    splice(last, {prev: node, node});
+    return this;
+  }
+
+  appendFront(list) {
+    if (list.next === list) return this;
+    let prevFrom = list,
+      nodeTo = getPrev(list);
+    splice(this, extract(prevFrom, nodeTo));
+    return this;
+  }
+
+  appendBack(list) {
+    if (list.next === list) return this;
+    let prevFrom = list,
+      nodeTo = getPrev(list),
+      last = getPrev(this);
+    splice(last, extract(prevFrom, nodeTo));
+    return this;
+  }
+
+  moveToFront(node) {
+    let prev;
+    if (node instanceof SList.SListPtr) {
+      prev = node.prev;
+      node = node.node;
+      if (this.next === node) return this;
+    } else {
+      if (this.next === node) return this;
+      prev = getPrev(this, node);
+    }
+    splice(this, extract(prev, node));
+    return this;
+  }
+
+  moveToBack(node) {
+    let prev;
+    if (node instanceof SList.SListPtr) {
+      prev = node.prev;
+      node = node.node;
+    } else {
+      prev = getPrev(this, node);
+    }
+    const last = getPrev(this);
+    splice(last, extract(prev, node));
+    return this;
+  }
+
+  clear() {
+    this.next = this;
+    return this;
+  }
+
+  remove(from, to = from) {
+    const prevFrom = from instanceof SList.SListPtr ? from.prev : getPrev(this, from),
+      nodeTo = to instanceof SList.SListPtr ? to.node : to;
+    extract(prevFrom, nodeTo);
+    return this;
+  }
+
+  extract(from, to) {
+    const prevFrom = from instanceof SList.SListPtr ? from.prev : getPrev(this, from),
+      nodeTo = to instanceof SList.SListPtr ? to.node : to;
+    return splice(new SList(), extract(prevFrom, nodeTo));
+  }
+
+  reverse() {
+    let prev = this,
+      current = prev.next;
+    while (current !== this) {
+      const next = current.next;
+      current.next = prev;
+      prev = current;
+      current = next;
+    }
+    this.next = prev;
+    return this;
+  }
+
+  sort(compareFn) {
+    let current = this.next;
+    for (const value of Array.from(this).sort(compareFn)) {
+      current.value = value;
+      current = current.next;
+    }
+    return this;
+  }
+
+  // iterators
+
+  [Symbol.iterator]() {
+    let current = this.next;
+    return {
+      next: () => {
+        if (current === this) return {done: true};
+        const node = current;
+        current = current.next;
+        return {value: node.value};
+      }
+    };
+  }
+
+  getIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = (from instanceof SList.SListPtr && from.node) || from || this.next;
+        const stop = to ? ((to instanceof SList.SListPtr && to.node) || to).next : this;
+        return {
+          next: () => {
+            if (current === stop) return {done: true};
+            const node = current;
+            current = current.next;
+            return {value: node.value};
+          }
+        };
+      }
+    };
+  }
+
+  getNodeIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = (from instanceof SList.SListPtr && from.node) || from || this.next;
+        const stop = to ? ((to instanceof SList.SListPtr && to.node) || to).next : this;
+        return {
+          next: () => {
+            if (current === stop) return {done: true};
+            const node = current;
+            current = current.next;
+            return {value: node};
+          }
+        };
+      }
+    };
+  }
+
+  getPtrIterable(from, to) {
+    return {
+      [Symbol.iterator]: () => {
+        let current = from instanceof SList.SListPtr ? from.clone() : from ? new SList.SListPtr(this, getPrev(this.head, from)) : this.getPtr();
+        const stop = to ? ((to instanceof SList.SListPtr && to.node) || to).next : this;
+        return {
+          next: () => {
+            if (current.node === stop) return {done: true};
+            const value = current.clone();
+            current.next();
+            return {value};
+          }
+        };
+      }
+    };
+  }
+
+  // helpers
+
+  makeFrom(values) {
+    return SList.from(values);
+  }
+
+  pushValuesFront(values) {
+    for (const value of values) {
+      this.pushFront(value);
+    }
+    return this;
+  }
+
+  appendValuesFront(values) {
+    return this.appendFront(SList.from(values));
+  }
+
+  static from(values) {
+    const list = new SList();
+    let prev = list;
+    for (const value of values) {
+      const node = new SListValueNode(value);
+      prev.next = node;
+      prev = node;
+    }
+    prev.next = list;
+    return list;
+  }
+}
+
+SList.pop = pop;
+SList.extract = extract;
+SList.splice = splice;
+SList.getPrev = getPrev;
+SList.getPrevPrev = getPrevPrev;
+
+SList.Node = SListNode;
+SList.ValueNode = SListValueNode;
+
+SList.prototype.pop = SList.prototype.popFront;
+SList.prototype.push = SList.prototype.pushFront;
+SList.prototype.append = SList.prototype.appendBack;
+
+SList.SListPtr = class SListPtr {
+  constructor(list, prev) {
+    this.list = list;
+    this.prev = prev || list;
+  }
+  get node() {
+    return this.prev.next;
+  }
+  get isHead() {
+    return this.prev.next === this.list;
+  }
+  next() {
+    this.prev = this.prev.next;
+    return this;
+  }
+  clone() {
+    return new SList.SListPtr(this.list, this.prev);
+  }
+};
+
+export default SList;