Merge pull request #1 from markpete/markpete/indices

Implementing skip lists to improve large data set performance

Author: markpete

README.md

@@ -1,7 +1,7 @@
 [![build status](https://travis-ci.org/markpete/SortedLinkedList.svg?branch=master)](http://travis-ci.org/markpete/SortedLinkedList)
 
 # Sorted Linked List Library #
-_This repository contains a library for managing a sorted, singly-linked, linked list.  The concept behind a linked-list is that developers can maintain an in-memory data structure to store a set of items without initially knowing the size and therefore without having to re-allocate arrays each time a limit is reached.  Furthermore in this implementation the overall sort is maintained on the data._
+_This repository contains a library for managing a sorted, singly-linked, linked list.  The concept behind a linked-list is that developers can maintain an in-memory data structure to store a set of items without initially knowing the size and therefore without having to re-allocate arrays each time a limit is reached.  Furthermore in this implementation the overall sort is maintained on the data and as the list get large, it converts to a skip-list to improve performance._
 
 ### Installation ###
 ```
@@ -70,4 +70,10 @@ var current = myList.iterator();
 while(!(x = current.next()).done) {
    console.log(x.value);
 };
+```
+### - toArray ###
+Converts the LinkedList to an Array
+```
+var myArray = myList.toArray();
+console.log(myArray.toString());
 ```

index.js

@@ -5,22 +5,37 @@ function LinkedList(parameters) {
     ( Object.prototype.toString.call( parameters.values ) !== '[object Array]' )) {
     return;
   }
-  for(var i=0; i<parameters.values.length; i++) {
+  for (var i=0; i<parameters.values.length; i++) {
     this.insert(parameters.values[i]);
   }
+  this._actionCount = 0;
 }
+
 LinkedList.prototype = {
   length: 0,
-  head: null
+  head: null,
+  _indices: [],
+  _actionCount: 0
 };
 
 LinkedList.prototype.insert = function(data) {
   var node = new LinkedList.Node(data);
+  this.actionCount();
   if (!this.head || node.data < this.head.data) {
     node.next = this.head;
     this.head = node;
+    if(this._indices.length > 0) {
+      this._indices.shift();
+      this._indices.unshift(node);
+    }
   } else {
-    current = this.head;
+    if(this._indices.length > 0) {
+      var i;
+      for(i=0; (i < this._indices.length) && (node.data > this._indices[i].data); i++);
+      current = this._indices[i-1];
+    } else {
+      current = this.head;
+    }
     while (current.next && current.next.data < node.data) {
       current = current.next;
     }
@@ -34,10 +49,32 @@ LinkedList.prototype.remove = function(data) {
   if (!this.head) {
     return false;
   }
+  this.actionCount();
   if (data === this.head.data) {
     this.head = this.head.next;
+    if(this._indices.length > 0) {
+      this._indices.shift();
+      if(this.head) {
+        this._indices.unshift(this.head);
+      } else {
+        this.actionCount(true);
+      }
+    }
   } else {
-    current = this.head;
+    if(this._indices.length > 0) {
+      var i;
+      for(i=0; (i < this._indices.length) && (data > this._indices[i].data); i++);
+      current = this._indices[i-1];
+      if(current === this._indices[i]) {
+        if(current.next) {
+          this._indices.splice(i,1, current.next);
+        } else {
+          this._indices.splice(i,1);
+        }
+      }
+    } else {
+      current = this.head;
+    }
     while (current.next && current.next.data < data) {
       current = current.next;
     }
@@ -70,6 +107,7 @@ LinkedList.prototype.contains = function(data) {
 LinkedList.prototype.clear = function () {
   this.head = null;
   this.length = 0;
+  this.actionCount(true);
 };
 
 LinkedList.prototype.iterator = function* () {
@@ -78,7 +116,39 @@ LinkedList.prototype.iterator = function* () {
     yield item.data;
     item = item.next;
   }
-}
+};
+
+LinkedList.prototype.actionCount = function (empty) {
+  if (empty) {
+    this._actionCount = 0;
+    return;
+  }
+  this._actionCount++;
+  if(this._actionCount > 2000) {
+    this._actionCount = 0;
+    this._indices = [];
+    if(this.length >= 2000) {
+      var index_point = Math.floor(this.length / 100);
+      var curr_node = this.head;
+      while(curr_node) {
+        this._indices.push(curr_node);
+        for(i=0;curr_node && i<index_point;i++) {
+          curr_node = curr_node.next;
+        }
+      }
+    }
+  }
+};
+
+LinkedList.prototype.toArray = function() {
+  var arr = [];
+  var current = this.head;
+  while(current) {
+    arr.push(current.data);
+    current = current.next;
+  }
+  return arr;
+};
 
 LinkedList.Node = function(data) {
   this.next = null;

package.json

@@ -12,6 +12,7 @@
   "keywords": [
     "linked list",
     "sorted linked list",
+    "skip list",
     "data structure",
     "abstract data type",
     "adt"

test.js

@@ -42,12 +42,14 @@ describe('sorted-linked-list', function() {
 	    expect(myList.length).to.equal(0);
 	});
 
-	it('create a list via array', function () {
+	it('list to and from array', function () {
 		myList = new LinkedList({values: ['dog', 'liger', 'cat', 'donkey']});
 		expect(myList).to.not.be.null;
 		expect(myList).to.be.ok;
 		expect(myList.length).to.equal(4);
 		expect(myList.head.data).to.equal('cat');
+		var myArray = myList.toArray();
+		expect(myArray).to.deep.equal(['cat', 'dog', 'donkey', 'liger']);
 	});
 
 	it('validate contains', function () {