✨ 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,
+};

src/insertFromBottomMostPredecessor.js

@@ -0,0 +1,19 @@
+import assert from 'assert';
+
+import node from './node';
+import heads from './heads';
+import predecessorOnPreviousLevel from './predecessorOnPreviousLevel';
+
+const insertFromBottomMostPredecessor = (p, pred, key) => {
+	assert(pred !== null);
+	let newNode = node(key, null, pred, pred.right);
+	while (heads(p)) {
+		pred = predecessorOnPreviousLevel(pred);
+		assert(pred !== null);
+		newNode = node(key, newNode, pred, pred.right);
+	}
+
+	return pred;
+};
+
+export default insertFromBottomMostPredecessor;

src/iter.js

@@ -0,0 +1,9 @@
+import assert from 'assert';
+
+export default function* iter(head) {
+	assert(head !== null);
+	while (head.right !== null) {
+		head = head.right;
+		yield head;
+	}
+}

src/iterDown.js

@@ -0,0 +1,6 @@
+export default function* iterDown(head) {
+	while (head !== null) {
+		yield head;
+		head = head.down;
+	}
+}

src/keys.js

@@ -0,0 +1,5 @@
+import iter from './iter';
+
+export default function* keys(level) {
+	for (const node of iter(level)) yield node.key;
+}

src/makeBottomLevel.js

@@ -0,0 +1,15 @@
+import Node from './Node';
+
+const makeBottomLevel = (compare, iterable) => {
+	const sorted = [...iterable].sort(compare);
+	const bottomLevelHead = new Node();
+	let current = bottomLevelHead;
+	for (const key of sorted) {
+		current = new Node(key, null, current);
+		current.left.right = current;
+	}
+
+	return bottomLevelHead;
+};
+
+export default makeBottomLevel;

src/makeDeterministic.js

@@ -0,0 +1,37 @@
+import assert from 'assert';
+import Node from './Node';
+
+/**
+ * Make a balanced Skip-list with p = 1/2.
+ */
+const makeDeterministic = (p, head) => {
+	assert(p === 1 / 2);
+
+	// Together, the if and while conditions guarantee that `makeQuasiRandom`
+	// does not do anything if the number of elements is <= 1
+	// TODO Could use some other constant?
+	if (head.right === null) return head;
+
+	while (head.right.right !== null) {
+		const newHead = new Node(head.key, head);
+
+		let current = head;
+		let next = newHead;
+		while (current.right !== null) {
+			current = current.right;
+			if (current.right === null) break; // Skip odd indexed nodes
+			current = current.right;
+			next = new Node(current.key, current, next);
+			next.left.right = next;
+			current.up = next;
+		}
+
+		head.up = newHead;
+		head = newHead;
+		assert(head.right !== null);
+	}
+
+	return head;
+};
+
+export default makeDeterministic;