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

Author: amejiarosario

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

book/content/part02/linked-list.asc

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

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}
+ */
+functionfindCycleStart(head){
+letslow=head;
+letfast=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.
+}
+returnslow;// return where the loop starts
+}
+}
+returnnull;// not found.
+}
+// end::fn[]
+
+// tag::brute[]
+functionfindCycleStartBrute(head){
+constvisited=newSet();
+letcurr=head;
+while(curr){
+if(visited.has(curr))returncurr;
+visited.add(curr);
+curr=curr.next;
+}
+returnnull;
+}
+// end::brute[]
+
+module.exports={ findCycleStart, findCycleStartBrute };

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',()=>{
+consthead=newLinkedList([1,2,3]).first;
+expect(fn(head)).toEqual(null);
+});
+
+it('should work with loop on first',()=>{
+constlist=newLinkedList([1,2,3]);
+constn1=list.first;
+list.last.next=n1;
+expect(fn(list.first)).toEqual(n1);
+});
+
+it('should work with loop on second',()=>{
+constlist=newLinkedList([1,2,3]);
+constn2=list.first.next;
+list.last.next=n2;
+expect(fn(list.first)).toEqual(n2);
+});
+});
+});

book/images/Words-Permutations.png

@@ -0,0 +1,45 @@
+// tag::fn[]
+/**
+ * Flatten a multi-level to a single level
+ * @param {Node} head
+ * @return {Node}
+ */
+functionflatten(head){
+for(letcurr=head;curr;curr=curr.next){
+if(!curr.child)continue;
+
+letlast=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.
+}
+
+returnhead;
+}
+// end::fn[]
+
+// tag::fn2[]
+functionflattenBrute(head){
+conststack=[];
+for(letcurr=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").
+}
+
+returnhead;
+}
+// end::fn2[]
+
+module.exports={ flatten, flattenBrute };

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');
+
+classNodeextendsListNode{
+constructor(value){
+super(value);
+this.child=null;
+}
+}
+
+// print linked list node with (previous and child)
+consttoString=(head)=>{
+constarr=[];
+for(leti=head;i;i=i.next){
+arr.push(`${i.value}(${(i.previous&&i.previous.value)||''},${(i.child&&i.child.value)||''})`);
+}
+return`{ ${arr.join(' -> ')} }`;
+};
+
+constll=(nums)=>Array.from(newLinkedList(nums,Node));
+
+[flatten,flattenBrute].forEach((fn)=>{
+describe(`flatten: ${fn.name}`,()=>{
+letl1,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,) }');
+});
+});
+});

book/images/cll.png

@@ -0,0 +1,39 @@
+// tag::fn[]
+functionisPalindrome(head){
+letslow=head;
+letfast=head;
+while(fast){// use slow/fast pointers to find the middle.
+slow=slow.next;
+fast=fast.next&&fast.next.next;
+}
+
+constreverseList=(node)=>{// use 3 pointers to reverse a linked list
+letprev=null;
+letcurr=node;
+while(curr){
+const{ next }=curr;// same as: "const next = curr.next;"
+curr.next=prev;
+prev=curr;
+curr=next;
+}
+returnprev;
+};
+
+constreversed=reverseList(slow);// head of the reversed half
+for(leti=reversed,j=head;i;i=i.next,j=j.next)if(i.value!==j.value)returnfalse;
+returntrue;
+}
+// end::fn[]
+
+// tag::fn2[]
+functionisPalindromeBrute(head){
+constarr=[];
+for(leti=head;i;i=i.next)arr.push(i.value);// <1>
+letlo=0;
+lethi=arr.length-1;
+while(lo<hi)if(arr[lo++]!==arr[hi--])returnfalse;// <2>
+returntrue;
+}
+// end::fn2[]
+
+module.exports={ isPalindrome, isPalindromeBrute };

book/images/course-schedule-examples.png

@@ -0,0 +1,19 @@
+const{ isPalindrome, isPalindromeBrute }=require('./linkedlist-is-palindrome');
+const{ LinkedList }=require('../../src');
+
+consttoList=(arr)=>newLinkedList(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);
+});
+});
+});

book/images/critical-connections-sol-examples.png

@@ -20,7 +20,6 @@ const { Queue } = require('../../src/index');
 classRecentCounter{
 // end::description[]
 // tag::solution[]
-queue=newQueue();
 // end::solution[]
 // tag::description[]
 /**
@@ -31,6 +30,7 @@ class RecentCounter {
 // end::description[]
 // tag::solution[]
 this.window=maxWindow;
+this.queue=newQueue();
 // 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();
 
 returnthis.queue.size;
 // end::solution[]

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[]
 functionsortColorsCompact(nums){
-leti=0,lo=0,hi=nums.length-1;
+leti=0;letlo=0;let
+hi=nums.length-1;
 constswap=(k,j)=>[nums[k],nums[j]]=[nums[j],nums[k]];
 
 while(i<=hi){