feat(book/linkedlist): linked lists techniques and common patterns

Author: amejiarosario

Diff for: .eslintrc.js

@@ -1,24 +1,35 @@
 module.exports = {
   extends: 'airbnb-base',
   env: {
-    jest: true
+    jest: true,
   },
+  plugins: ['jest'],
   globals: {
     BigInt: true,
   },
+
+  // check package.json for files to include
+  // files: ['src/**/*.js', 'book/interview-questions/*.js'],
+
   rules: {
     // https://github.com/airbnb/javascript/issues/1089
 
     // https://stackoverflow.com/a/35637900/684957
     // allow to add properties to arguments
-    'no-param-reassign': [2, { 'props': false }],
+    'no-param-reassign': [2, { props: false }],
 
     // https://eslint.org/docs/rules/no-plusplus
     // allows unary operators ++ and -- in the afterthought (final expression) of a for loop.
-    'no-plusplus': [0, { 'allowForLoopAfterthoughts': true }],
+    'no-plusplus': [0, { allowForLoopAfterthoughts: true }],
     'no-continue': [0],
 
     // Allow for..of
     'no-restricted-syntax': [0, 'ForOfStatement'],
-  }
+
+    // jest plugin
+    // 'jest/no-disabled-tests': 'warn',
+    'jest/no-focused-tests': 'error',
+    'jest/no-identical-title': 'warn',
+    'jest/valid-expect': 'warn',
+  },
 };

Diff for: book/content/part02/linked-list.asc

@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 const { dailyTemperatures } = require('./daily-temperatures');
 
 describe('Stack: Daily Temperatures', () => {

Diff for: book/images/Find-the-largest-sum.png

@@ -0,0 +1,39 @@
+// tag::fn[]
+/**
+ * Find where the cycle starts or null if no loop.
+ * @param {Node} head - The head of the list
+ * @returns {Node|null}
+ */
+function findCycleStart(head) {
+  let slow = head;
+  let fast = head;
+  while (fast && fast.next) {
+    slow = slow.next; // slow moves 1 by 1.
+    fast = fast.next.next; // slow moves 2 by 2.
+    if (fast === slow) { // detects loop!
+      slow = head; // reset pointer to begining.
+      while (slow !== fast) { // find intersection
+        slow = slow.next;
+        fast = fast.next; // move both pointers one by one this time.
+      }
+      return slow; // return where the loop starts
+    }
+  }
+  return null; // not found.
+}
+// end::fn[]
+
+// tag::brute[]
+function findCycleStartBrute(head) {
+  const visited = new Set();
+  let curr = head;
+  while (curr) {
+    if (visited.has(curr)) return curr;
+    visited.add(curr);
+    curr = curr.next;
+  }
+  return null;
+}
+// end::brute[]
+
+module.exports = { findCycleStart, findCycleStartBrute };

Diff for: book/images/Recursive-Fibonacci-call-tree-with-dp.png

@@ -0,0 +1,25 @@
+const { findCycleStart, findCycleStartBrute } = require('./linkedlist-find-cycle-start');
+const { LinkedList } = require('../../src/index');
+
+[findCycleStart, findCycleStartBrute].forEach((fn) => {
+  describe(`findCycleStart: ${fn.name}`, () => {
+    it('should work without loop', () => {
+      const head = new LinkedList([1, 2, 3]).first;
+      expect(fn(head)).toEqual(null);
+    });
+
+    it('should work with loop on first', () => {
+      const list = new LinkedList([1, 2, 3]);
+      const n1 = list.first;
+      list.last.next = n1;
+      expect(fn(list.first)).toEqual(n1);
+    });
+
+    it('should work with loop on second', () => {
+      const list = new LinkedList([1, 2, 3]);
+      const n2 = list.first.next;
+      list.last.next = n2;
+      expect(fn(list.first)).toEqual(n2);
+    });
+  });
+});

Diff for: book/images/Words-Permutations.png

@@ -0,0 +1,45 @@
+// tag::fn[]
+/**
+ * Flatten a multi-level to a single level
+ * @param {Node} head
+ * @return {Node}
+ */
+function flatten(head) {
+  for (let curr = head; curr; curr = curr.next) {
+    if (!curr.child) continue;
+
+    let last = curr.child;
+    while (last && last.next) last = last.next; // find "child"'s last
+    if (curr.next) { // move "next" to "child"'s last postion
+      last.next = curr.next;
+      curr.next.previous = last;
+    }
+    curr.next = curr.child; // override "next" with "child".
+    curr.child.previous = curr;
+    curr.child = null; // clean "child" pointer.
+  }
+
+  return head;
+}
+// end::fn[]
+
+// tag::fn2[]
+function flattenBrute(head) {
+  const stack = [];
+  for (let curr = head; curr; curr = curr.next) {
+    if (!curr.next && stack.length) {
+      curr.next = stack.pop(); // merge main thread with saved nodes.
+      curr.next.previous = curr;
+    }
+    if (!curr.child) continue;
+    if (curr.next) stack.push(curr.next); // save "next" nodes.
+    curr.next = curr.child; // override next pointer with "child"
+    curr.child.previous = curr;
+    curr.child = null; // clear child pointer (was moved to "next").
+  }
+
+  return head;
+}
+// end::fn2[]
+
+module.exports = { flatten, flattenBrute };

Diff for: book/images/cll-fast-slow-pointers.png

@@ -0,0 +1,79 @@
+/* eslint-disable one-var, one-var-declaration-per-line, prefer-destructuring */
+const { flatten, flattenBrute } = require('./linkedlist-flatten-multilevel');
+const { LinkedList } = require('../../src/index');
+const { ListNode } = require('../../src/index');
+
+class Node extends ListNode {
+  constructor(value) {
+    super(value);
+    this.child = null;
+  }
+}
+
+// print linked list node with (previous and child)
+const toString = (head) => {
+  const arr = [];
+  for (let i = head; i; i = i.next) {
+    arr.push(`${i.value}(${(i.previous && i.previous.value) || ''},${(i.child && i.child.value) || ''})`);
+  }
+  return `{ ${arr.join(' -> ')} }`;
+};
+
+const ll = (nums) => Array.from(new LinkedList(nums, Node));
+
+[flatten, flattenBrute].forEach((fn) => {
+  describe(`flatten: ${fn.name}`, () => {
+    let l1, l2, l3, l4;
+
+    beforeEach(() => {
+      l1 = ll([1, 2, 3]);
+      l2 = ll([10, 12, 14, 16]);
+      l3 = ll([21, 23]);
+      l4 = ll([36, 37]);
+    });
+
+    it('works with flat 1 level', () => {
+      // 1--- 2--- 3
+      expect(toString(fn(l1[0]))).toEqual('{ 1(,) -> 2(1,) -> 3(2,) }');
+    });
+
+    it('works with flat 2 levels', () => {
+      // 21--23
+      //      |
+      //      36--37
+      l3[1].child = l4[0];
+      expect(toString(l3[0])).toEqual('{ 21(,) -> 23(21,36) }');
+      expect(toString(fn(l3[0]))).toEqual('{ 21(,) -> 23(21,) -> 36(23,) -> 37(36,) }');
+    });
+
+    fit('works with flat 2 levels and reminder', () => {
+      // 1--- 2--- 3
+      //      |
+      //      36--37
+      l1[1].child = l4[0];
+      expect(toString(l1[0])).toEqual('{ 1(,) -> 2(1,36) -> 3(2,) }');
+
+      expect(toString(fn(l1[0]))).toEqual('{ 1(,) -> 2(1,) -> 36(2,) -> 37(36,) -> 3(37,) }');
+    });
+
+    it('should flatten 3 levels', () => {
+      // 1--- 2--- 3
+      //      |
+      //     10---12---14---16
+      //           |    |
+      //           |   36---37
+      //           |
+      //           21--23
+      l1[1].child = l2[0];
+      l2[1].child = l3[0];
+      l2[2].child = l4[0];
+
+      // verify list children are present
+      expect(toString(l1[0])).toEqual('{ 1(,) -> 2(1,10) -> 3(2,) }');
+      expect(toString(l2[0])).toEqual('{ 10(,) -> 12(10,21) -> 14(12,36) -> 16(14,) }');
+
+      // run
+      expect(toString(fn(l1[0]))).toEqual('{ 1(,) -> 2(1,) -> 10(2,) -> 12(10,) -> 21(12,) -> 23(21,) -> 14(23,) -> 36(14,) -> 37(36,) -> 16(37,) -> 3(16,) }');
+    });
+  });
+});

Diff for: book/images/cll.png

@@ -0,0 +1,39 @@
+// tag::fn[]
+function isPalindrome(head) {
+  let slow = head;
+  let fast = head;
+  while (fast) { // use slow/fast pointers to find the middle.
+    slow = slow.next;
+    fast = fast.next && fast.next.next;
+  }
+
+  const reverseList = (node) => { // use 3 pointers to reverse a linked list
+    let prev = null;
+    let curr = node;
+    while (curr) {
+      const { next } = curr; // same as: "const next = curr.next;"
+      curr.next = prev;
+      prev = curr;
+      curr = next;
+    }
+    return prev;
+  };
+
+  const reversed = reverseList(slow); // head of the reversed half
+  for (let i = reversed, j = head; i; i = i.next, j = j.next) if (i.value !== j.value) return false;
+  return true;
+}
+// end::fn[]
+
+// tag::fn2[]
+function isPalindromeBrute(head) {
+  const arr = [];
+  for (let i = head; i; i = i.next) arr.push(i.value); // <1>
+  let lo = 0;
+  let hi = arr.length - 1;
+  while (lo < hi) if (arr[lo++] !== arr[hi--]) return false; // <2>
+  return true;
+}
+// end::fn2[]
+
+module.exports = { isPalindrome, isPalindromeBrute };

Diff for: book/images/course-schedule-examples.png

@@ -0,0 +1,19 @@
+const { isPalindrome, isPalindromeBrute } = require('./linkedlist-is-palindrome');
+const { LinkedList } = require('../../src');
+
+const toList = (arr) => new LinkedList(arr).first;
+
+[isPalindrome, isPalindromeBrute].forEach((fn) => {
+  describe(`isPalindrome: ${fn.name}`, () => {
+    it('should work', () => {
+      expect(fn()).toEqual(true);
+    });
+
+    it('should work different cases', () => {
+      expect(fn(toList([1, 2, 3]))).toEqual(false);
+      expect(fn(toList([1, 2, 3, 2, 1]))).toEqual(true);
+      expect(fn(toList([1, 1, 2, 1]))).toEqual(false);
+      expect(fn(toList([1, 2, 2, 1]))).toEqual(true);
+    });
+  });
+});

Diff for: book/images/critical-connections-sol-examples.png

@@ -20,7 +20,6 @@ const { Queue } = require('../../src/index');
 class RecentCounter {
   // end::description[]
   // tag::solution[]
-  queue = new Queue();
   // end::solution[]
   // tag::description[]
   /**
@@ -31,6 +30,7 @@ class RecentCounter {
   // end::description[]
   // tag::solution[]
     this.window = maxWindow;
+    this.queue = new Queue();
   // end::solution[]
   // tag::description[]
   }
@@ -44,8 +44,7 @@ class RecentCounter {
   // end::description[]
   // tag::solution[]
     this.queue.enqueue(timestamp);
-    while (timestamp - this.queue.peek() > this.window)
-      this.queue.dequeue();
+    while (timestamp - this.queue.peek() > this.window) this.queue.dequeue();
 
     return this.queue.size;
   // end::solution[]

Diff for: book/images/critical-path-examples.png

@@ -1,3 +1,4 @@
+/* eslint-disable no-return-assign */
 // const {  } = require('../../src/index');
 
 // tag::description[]
@@ -35,7 +36,8 @@ function sortColors(nums) {
 
 // tag::compact[]
 function sortColorsCompact(nums) {
-  let i = 0, lo = 0, hi = nums.length - 1;
+  let i = 0; let lo = 0; let
+    hi = nums.length - 1;
   const swap = (k, j) => [nums[k], nums[j]] = [nums[j], nums[k]];
 
   while (i <= hi) {

Diff for: book/images/mll-3-levels.png

@@ -15,10 +15,11 @@
   "scripts": {
     "test": "jest --verbose",
     "watch": "jest --watch --coverage",
-    "ci": "npx eslint src/ && jest --coverage",
+    "lint:base": "npx eslint --fix '{src,book/interview-questions}/**/*.js'",
+    "lint": "npm run lint:base -- --format codeframe",
+    "ci": "npm run lint:base && jest --coverage",
     "coverage": "jest --coverage && open coverage/lcov-report/index.html",
     "coverage:win": "jest --coverage && cmd.exe /C start coverage/lcov-report/index.html",
-    "lint": "npx eslint --fix --format codeframe src/",
     "semantic-release": "semantic-release",
     "release:check": "semantic-release --dry-run"
   },
@@ -40,10 +41,10 @@
     "commitizen": "4.1.2",
     "conventional-changelog-cli": "2.0.34",
     "cz-conventional-changelog": "3.2.0",
-    "eslint": "7.0.0",
+    "eslint": "7.12.1",
     "eslint-config-airbnb-base": "14.1.0",
     "eslint-plugin-import": "2.20.2",
-    "eslint-plugin-jest": "23.11.0",
+    "eslint-plugin-jest": "24.1.0",
     "handlebars": "4.7.6",
     "husky": "4.2.5",
     "jest": "26.0.1",

Diff for: book/images/sll-fast-slow-pointers.png

@@ -1,16 +1,24 @@
 const util = require('util');
-const Node = require('./node');
+const Node = require('./node'); // Doubly
 
 // tag::constructor[]
 /**
  * Doubly linked list that keeps track of
  * the last and first element
  */
 class LinkedList {
-  constructor(iterable = []) {
+  constructor(
+    iterable = [],
+    // end::constructor[]
+    ListNode = Node, // Node class (e.g. singly, doubly, multilevel)
+    // tag::constructor[]
+  ) {
     this.first = null; // head/root element
     this.last = null; // last element of the list
     this.size = 0; // total number of elements in the list
+    // end::constructor[]
+    this.ListNode = ListNode; // ListNode class
+    // tag::constructor[]
 
     Array.from(iterable, (i) => this.addLast(i));
   }
@@ -20,10 +28,10 @@ class LinkedList {
   /**
    * Adds element to the begining of the list. Similar to Array.unshift
    * Runtime: O(1)
-   * @param {any} value
+   * @param {Node} value
    */
   addFirst(value) {
-    const newNode = new Node(value);
+    const newNode = new this.ListNode(value);
 
     newNode.next = this.first;
 
@@ -246,16 +254,14 @@ class LinkedList {
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#User-defined_iterables
    */
   * [Symbol.iterator]() {
-    for (let node = this.first, position = 0;
-      node;
-      position += 1, node = node.next) {
-      yield { node, position };
+    for (let node = this.first; node; node = node.next) {
+      yield node;
     }
   }
 
   toString() {
     const parts = [...this]; // see [Symbol.iterator]()
-    return parts.map((n) => util.inspect(n.node.value)).join(' -> ');
+    return parts.map((n) => util.inspect(n.value)).join(' -> ');
   }
 
   /**

Diff for: book/images/sllx4.png

@@ -429,5 +429,24 @@ describe('LinkedList Test', () => {
         expect(linkedList.toString()).toBe("'a' -> 2 -> 'c' -> { k: 4, v: 'd' }");
       });
     });
+
+
+    describe('iterator', () => {
+      let a;
+      let b;
+      let c;
+      let d;
+      beforeEach(() => {
+        a = linkedList.addLast('a');
+        b = linkedList.addLast('b');
+        c = linkedList.addLast('c');
+        d = linkedList.addLast('d');
+      });
+
+      it('should convert to array of nodes', () => {
+        expect([...linkedList]).toEqual([a, b, c, d]);
+        expect(Array.from(linkedList)).toEqual([a, b, c, d]);
+      });
+    });
   });
 });

Diff for: book/interview-questions/daily-temperatures.spec.js

@@ -1,14 +1,18 @@
 // tag::snippet[]
 /**
- * Node with reference to next and previous element
+ * Linked List Node
  */
+// tag::singly[]
 class Node {
   constructor(value = null) {
     this.value = value;
     this.next = null;
-    this.previous = null; // for doubly linked list
+    // end::singly[]
+    this.previous = null; // if doubly linked list
+    // tag::singly[]
   }
 }
+// end::singly[]
 // end::snippet[]
 
 module.exports = Node;

Diff for: book/interview-questions/linkedlist-find-cycle-start.js

@@ -1,5 +1,6 @@
 // data structures
 const LinkedList = require('./data-structures/linked-lists/linked-list');
+const ListNode = require('./data-structures/linked-lists/node');
 const Queue = require('./data-structures/queues/queue');
 const Stack = require('./data-structures/stacks/stack');
 const Graph = require('./data-structures/graphs/graph');
@@ -29,6 +30,7 @@ const mergeSort = require('./algorithms/sorting/merge-sort');
 
 module.exports = {
   LinkedList,
+  ListNode,
   Queue,
   Stack,
   Graph,