✨ feat: First draft.

Author: make-github-pseudonymous-again

README.md

@@ -1,4 +1,4 @@
-[@aureooms/js-skip-list](https://aureooms.github.io/js-skip-list)
+:fast_forward: [@aureooms/js-skip-list](https://aureooms.github.io/js-skip-list)
 ==
 
 Skip list data structure for JavaScript.

package.json

@@ -27,6 +27,7 @@
             "transform-remove-console",
             {
               "exclude": [
+                "debug",
                 "log",
                 "error",
                 "warn"
@@ -77,6 +78,10 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@aureooms/js-cardinality": "^2.0.0",
+    "@aureooms/js-compare": "^1.4.8",
+    "@aureooms/js-itertools": "^4.1.0",
+    "@aureooms/js-random": "^2.0.0",
     "@babel/cli": "7.11.6",
     "@babel/core": "7.11.6",
     "@babel/preset-env": "7.11.5",
@@ -101,7 +106,15 @@
     "lib"
   ],
   "homepage": "https://aureooms.github.io/js-skip-list",
-  "keywords": ["data", "list", "randomized", "skip", "skip-list", "skiplist", "structures"],
+  "keywords": [
+    "data",
+    "list",
+    "randomized",
+    "skip",
+    "skip-list",
+    "skiplist",
+    "structures"
+  ],
   "license": "AGPL-3.0",
   "main": "lib/index.js",
   "prettier": {
@@ -133,12 +146,7 @@
       "unicorn"
     ],
     "rules": {
-      "unicorn/filename-case": [
-        "error",
-        {
-          "case": "camelCase"
-        }
-      ]
+      "unicorn/filename-case": "off"
     }
   }
 }

src/Node.js

@@ -0,0 +1,13 @@
+export default function Node(
+	key = undefined,
+	down = null,
+	left = null,
+	right = null,
+	up = null,
+) {
+	this.key = key;
+	this.right = right;
+	this.down = down;
+	this.left = left;
+	this.up = up;
+}

src/SkipList.js

@@ -0,0 +1,97 @@
+import assert from 'assert';
+import Node from './Node';
+import keys from './keys';
+import iter from './iter';
+import downMost from './downMost';
+import searchTopMost from './searchTopMost';
+import bottomMostPredecessor from './bottomMostPredecessor';
+import deleteFromTopMost from './deleteFromTopMost';
+import insertFromBottomMostPredecessor from './insertFromBottomMostPredecessor';
+import makeQuasiRandom from './makeQuasiRandom';
+import makeBottomLevel from './makeBottomLevel';
+
+/**
+ * @param {Number} p Promotion probability in (0,1).
+ * @param {Function} compare
+ */
+export default function SkipList(p, compare, head = new Node()) {
+	this.head = head; // Sentinel node
+	this.p = p;
+	this.compare = compare;
+}
+
+SkipList.prototype.add = function (key) {
+	const node = bottomMostPredecessor(this.compare, this.head, key);
+	const pred = insertFromBottomMostPredecessor(this.p, node, key);
+	if (pred.left === null && pred.up === null) this.head = pred;
+};
+
+SkipList.prototype.get = function (key) {
+	const node = searchTopMost(this.compare, this.head, key);
+	return node === null ? null : node.key;
+};
+
+SkipList.prototype.has = function (key) {
+	return searchTopMost(this.compare, this.head, key) !== null;
+};
+
+SkipList.prototype.remove = function (key) {
+	const node = searchTopMost(this.compare, this.head, key);
+	if (node === null) return false;
+
+	deleteFromTopMost(node);
+	return true;
+};
+
+SkipList.prototype._predecessor = function (key) {
+	return bottomMostPredecessor(this.compare, this.head, key);
+};
+
+SkipList.prototype.levelOne = function () {
+	return downMost(this.head);
+};
+
+SkipList.prototype.levels = function () {
+	assert(this.head !== null);
+	let k = 0;
+	let current = this.head;
+	do {
+		++k;
+		current = current.down;
+	} while (current !== null);
+
+	return k;
+};
+
+SkipList.prototype.keys = function () {
+	const level = this.levelOne();
+	return keys(level);
+};
+
+SkipList.prototype.values = function () {
+	return this.keys();
+};
+
+SkipList.prototype[Symbol.iterator] = function () {
+	return this.keys();
+};
+
+SkipList.prototype.range = function* (left, right) {
+	const pred = this._predecessor(left);
+	for (const node of iter(pred)) {
+		if (this.compare(node.key, right) >= 0) break;
+		yield node.key;
+	}
+};
+
+SkipList.from = (compare, iterable, p = 1 / 2) => {
+	if (p === 1 / 2) {
+		const bottomLevelHead = makeBottomLevel(compare, iterable);
+		const head = makeQuasiRandom(p, bottomLevelHead);
+		return new SkipList(p, compare, head);
+	}
+
+	const list = new SkipList(p, compare);
+	for (const key of iterable) list.add(key);
+	return list;
+};

src/bottomMostPredecessor.js

@@ -0,0 +1,17 @@
+import assert from 'assert';
+
+const bottomMostPredecessor = (compare, node, key) => {
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		assert(node !== null);
+		// Predecessor search on current level
+		while (node.right !== null && compare(key, node.right.key) > 0)
+			node = node.right;
+
+		// Continue on bottom level or abandon
+		if (node.down === null) return node;
+		node = node.down;
+	}
+};
+
+export default bottomMostPredecessor;

src/debug.js

@@ -0,0 +1,10 @@
+import iter from './iter';
+import iterDown from './iterDown';
+import {enumerate} from '@aureooms/js-itertools';
+import {count} from '@aureooms/js-cardinality';
+
+export default function* debug(skiplist) {
+	for (const [k, sentinel] of enumerate(iterDown(skiplist.head))) {
+		yield [k, count(iter(sentinel))];
+	}
+}

src/deleteFromTopMost.js

@@ -0,0 +1,14 @@
+import assert from 'assert';
+
+const deleteFromTopMost = (node) => {
+	assert(node !== null);
+	assert(node.up === null); // Node is from top-most level
+	do {
+		assert(node.left !== null); // Node is not sentinel
+		node.left.right = node.right;
+		if (node.right !== null) node.right.left = node.left;
+		node = node.down;
+	} while (node !== null);
+};
+
+export default deleteFromTopMost;

src/downMost.js

@@ -0,0 +1,9 @@
+import assert from 'assert';
+
+const downMost = (node) => {
+	assert(node !== null);
+	while (node.down !== null) node = node.down;
+	return node;
+};
+
+export default downMost;

src/heads.js

@@ -0,0 +1,6 @@
+// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random
+// "The Math.random() function returns a floating-point, pseudo-random number in
+// the range 0 to less than 1 (inclusive of 0, but not 1)"
+const heads = (bias = 1 / 2) => Math.random() < bias;
+
+export default heads;

src/index.js

@@ -0,0 +1,39 @@
+import Node from './Node';
+import SkipList from './SkipList';
+import bottomMostPredecessor from './bottomMostPredecessor';
+import debug from './debug';
+import deleteFromTopMost from './deleteFromTopMost';
+import downMost from './downMost';
+import heads from './heads';
+import insertFromBottomMostPredecessor from './insertFromBottomMostPredecessor';
+import iter from './iter';
+import iterDown from './iterDown';
+import keys from './keys';
+import makeBottomLevel from './makeBottomLevel';
+import makeDeterministic from './makeDeterministic';
+import makeQuasiRandom from './makeQuasiRandom';
+import node from './node';
+import predecessorOnPreviousLevel from './predecessorOnPreviousLevel';
+import searchTopMost from './searchTopMost';
+
+export default SkipList;
+
+export {
+	Node,
+	SkipList,
+	bottomMostPredecessor,
+	debug,
+	deleteFromTopMost,
+	downMost,
+	heads,
+	insertFromBottomMostPredecessor,
+	iter,
+	iterDown,
+	keys,
+	makeBottomLevel,
+	makeDeterministic,
+	makeQuasiRandom,
+	node,
+	predecessorOnPreviousLevel,
+	searchTopMost,
+};