Added solution to ch2-8 and associated tests. Update ch2 helpers and made use of new methods in ch2-7 tests.

Author: diadical

src/chapter2/ch2-q7.spec.js

@@ -3,23 +3,11 @@ import * as helpers from './helpers';
 import * as funcs from './ch2-q7';
 
 function generateList(length) {
-  let head, tail;
-
+  let list = helpers.createLinkedList();
   for (let i = length; i > 0; --i) {
-    let node = helpers.createNode(100 + Math.random() * 999999);
-    if (!head) {
-      head = tail = node;
-    }
-    else {
-      tail.next = node;
-      tail = node;
-    }
+    helpers.pushSingle(list, 100 + Math.random() * 999999);
   }
-
-  return {
-    head: head,
-    tail: tail
-  };
+  return list;
 }
 
 for (let key in funcs) {

src/chapter2/ch2-q8.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * This algorithm simply stores each node it sees into a Set structure, if there
+ * is a cycle then the first repeat we see will be the start of that cycle and
+ * the value we should return.
+ *
+ * N = |list|
+ * Time: O(N) - assumes Set is hashmap based so O(1) costs
+ * Additional space: O(N)
+ */
+export function findStartOfLoopSet(list) {
+  let visited = new Set(),
+    node = list;
+
+  while (node) {
+    if (visited.has(node)) {
+      return node;
+    }
+    visited.add(node);
+    node = node.next;
+  }
+
+  return null;
+}
+
+/**
+ * This algorithm uses the runners principle where we have a slow and fast (2x)
+ * runners that both traverse the list. If at some point both runners point to
+ * the same node then there is a cycle. Due to the different rate at which they
+ * travel they will meet k steps 'before' the start of the cycle so if you reset
+ * the slow runner back to the start and leave the faster runner at the meeting
+ * point, when they start moving forward again they will eventually meet at the
+ * start of the cycle.
+ *
+ * N = |list|
+ * Time: O(N)
+ * Additional space: O(1)
+ */
+export function findStartOfLoop(list) {
+  if (!list) {
+    return null;
+  }
+
+  let slow = list,
+    fast = list;
+
+  while (slow.next && fast.next && fast.next.next) {
+    slow = slow.next;
+    fast = fast.next.next;
+    if (fast === slow) {
+      break;
+    }
+  }
+
+  if (!slow || slow !== fast) { // no loop
+    return null;
+  }
+
+  slow = list;
+  while (slow !== fast) {
+    slow = slow.next;
+    fast = fast.next;
+  }
+
+  return fast;
+}

src/chapter2/ch2-q8.spec.js

@@ -0,0 +1,45 @@
+import { expect } from 'chai';
+import * as helpers from './helpers';
+import * as funcs from './ch2-q8';
+
+for (let key in funcs) {
+  let func = funcs[key];
+
+  describe('ch2-q8: ' + key, function() {
+
+    beforeEach(function() {
+      this.list = helpers.createLinkedList();
+    });
+
+    it('returns null with empty list', function() {
+      expect(func(this.list.head)).to.be.null;
+    });
+
+    it('returns null when there is no loop', function() {
+      helpers.push(this.list, 1, 2, 3, 4, 5, 6);
+      expect(func(this.list.head)).to.be.null;
+    });
+
+    it('returns node when there is a loop 1', function() {
+      helpers.push(this.list, 1, 2, 3, 4, 5, 6);
+      let node = this.list.head;
+      this.list.tail.next = node;
+      expect(func(this.list.head)).to.equal(node);
+    });
+
+    it('returns node when there is a loop 2', function() {
+      helpers.push(this.list, 1, 2, 3, 4, 5, 6);
+      let node = this.list.head.next.next.next;
+      this.list.tail.next = node;
+      expect(func(this.list.head)).to.equal(node);
+    });
+
+    it('returns node when there is a loop 3', function() {
+      helpers.push(this.list, 1, 2, 3, 4, 5, 6);
+      let node = this.list.tail;
+      this.list.tail.next = node;
+      expect(func(this.list.head)).to.equal(node);
+    });
+
+  });
+}

src/chapter2/helpers.js

@@ -40,3 +40,28 @@ export function getLength(list) {
   }
   return length;
 }
+
+export function createLinkedList() {
+  return {
+    head: null,
+    tail: null
+  };
+}
+
+export function pushSingle(list, value) {
+  let node = createNode(value);
+  if (list.head) {
+    list.tail.next = node;
+    list.tail = node;
+  }
+  else {
+    list.head = node;
+    list.tail = node;
+  }
+}
+
+export function push(list) {
+  for (let i = 1; i < arguments.length; ++i) {
+    pushSingle(list, arguments[i]);
+  }
+}