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

Author: amejiarosario

book/content/part02/linked-list.asc

@@ -35,10 +35,18 @@ In a singly linked list, each element or node is *connected* to the next one by
 Usually, a Linked List is referenced by the first element called *head* (or *root* node). Let's say that we have a list of strings with the following values: `"art" -> "dog" -> "cat"`. It would look something like the following image.
 
 .Singly Linked List Representation: each node has a reference (blue arrow) to the next one.
-image::image19.png[image,width=498,height=97]
+image::sllx4.png[]
 
 If you want to get the `cat` element from the example above, then the only way to get there is by using the `next` field on the head node. You would get `art` first, then use the next field recursively until you eventually get the `cat` element.
 
+==== Circular Linked Lists
+
+Circular linked lists happen when the last node points to any node on the list, creating a loop. In the following illustration, you can see two circular linked lists.
+
+image:cll.png[Circular linked lists examples]
+
+One circular linked list happens when the last element points to the first element. Another kind of circular linked list is when the last node points to any node in the middle. There are some efficient algorithms to detect when the list has a loop or not. More on that later in this chapter.
+
 [[doubly-linked-list]]
 ==== Doubly Linked List
 
@@ -51,19 +59,14 @@ With a doubly-linked list, you can move not only forward but also backward. If y
 
 Finding an item on the linked list takes O(n) time. Because in the worst-case, you will have to iterate over the whole list.
 
-==== Linked List vs. Array
-
-Arrays give you instant access to data anywhere in the collection using an index. However, Linked List visits nodes in sequential order. In the worst-case scenario, it takes _O(n)_ to get an element from a Linked List. You might be wondering: Isn’t an array always more efficient with _O(1)_ access time? It depends.
-
-We also have to understand the space complexity to see the trade-offs between arrays and linked lists. An array pre-allocates contiguous blocks of memory. If the array fillup, it has to create a larger array (usually 2x) and copy all the elements when it is getting full.  That takes _O(n)_ to copy all the items over. On the other hand, LinkedList’s nodes only reserve precisely the amount of memory they need. They don’t have to be next to each other in RAM, nor are large chunks of memory is booked beforehand like arrays. Linked List is more on a "grow as you go" basis. *Linked list wins on memory usage over an array.*
-
-Another difference is that adding/deleting at the beginning of an array takes `O(n)`; however, the linked list is a constant operation `O(1)` as we will implement later. *Linked List has better runtime than an array for inserting items at the beginning.*
 
 ==== Implementing a Linked List
 
 We are going to implement a doubly linked list. First, let's start with the constructor.
 
-The only must-have field on the constructor is the `first` or head reference.  If you want to insert it to the back of the list in constant time, then `last` pointer is needed. Everything else is complimentary.
+TIP: if you want to implement a singly linked list instead, it's the same in most parts, but without the setting the `previous` pointers.
+
+The only must-have field on the constructor is the `first` or head reference.  If you want to insert data to the back of the list in constant time, then the `last` pointer is needed. Everything else is complimentary.
 
 .Linked List's constructor
 [source, javascript]
@@ -201,7 +204,7 @@ As you can see, when we want to remove the first node, we make the 2nd element (
 
 ===== Deleting element from the tail
 
-Removing the last element from the list would require iterate from the head until we find the last one, that’s `O(n)`. But, since we referenced the last element, we can do it in _O(1)_ instead!
+Removing the last element from the list would require iterate from the head until we find the last one: `O(n)`. But, since we referenced the last element, we can do it in _O(1)_ instead!
 
 .Removing the last element from the list.
 image::dll-remove-last.png[]
@@ -239,7 +242,13 @@ Notice that we are using the `get` method to get the node at the current positio
 
 (((Tables, Linear DS, Array/Lists complexities)))
 
-==== Linked List Complexity vs. Array Complexity
+==== Linked List vs. Array
+
+Arrays give you instant access to data anywhere in the collection using an index. However, Linked List visits nodes in sequential order. In the worst-case scenario, it takes _O(n)_ to get an element from a Linked List. You might be wondering: Isn’t an array always more efficient with _O(1)_ access time? It depends.
+
+We also have to understand the space complexity to see the trade-offs between arrays and linked lists. An array pre-allocates contiguous blocks of memory. If the array fillup, it has to create a larger array (usually 2x) and copy all the elements when it is getting full.  That takes _O(n)_ to copy all the items over. On the other hand, LinkedList’s nodes only reserve precisely the amount of memory they need. They don’t have to be next to each other in RAM, nor are large chunks of memory is booked beforehand like arrays. Linked List is more on a "grow as you go" basis. *Linked list wins on memory usage over an array.*
+
+Another difference is that adding/deleting at the beginning of an array takes `O(n)`; however, the linked list is a constant operation `O(1)` as we will implement later. *Linked List has better runtime than an array for inserting items at the beginning.*
 
 // tag::table[]
 .Big O cheat sheet for Linked List and Array
@@ -269,6 +278,202 @@ Comparing an array with a doubly-linked list, both have different use cases:
 
 For the next two linear data structures <<part02-linear-data-structures#stack>> and <<part02-linear-data-structures#queue>>, we are going to use a doubly-linked list to implement them. We could use an array as well, but since inserting/deleting from the start performs better with linked-lists, we will use that.
 
+==== Linked List patterns for Interview Questions
+
+Most linked list problems are solved using 1 to 3 pointers. Sometimes we move them in tandem or individually.
+
+.Examples of problems that can be solved using multiple pointers:
+- Detecting if the linked list is circular (has a loop).
+- Finding the middle node of a linked list in 1-pass without any auxiliary data structure.
+- Reversing the linked list in 1-pass without any auxiliary data structure. e.g. `1->2->3` to `3->2->1`.
+
+Let's do some examples!
+
+===== Fast/Slow Pointers
+
+One standard algorithm to detect loops in a linked list is fast/slow runner pointers (a.k.a The Tortoise 🐢 and the Hare🐇 or Floyd’s Algorithm). The slow pointer moves one node per iteration, while the fast pointer moves two nodes every time. You can see an example code below:
+
+.Fast/Slow pointers
+[source, javascript]
+----
+let fast = head, slow = head;
+while (fast && fast.next) {
+  slow = slow.next; // slow moves 1 by 1.
+  fast = fast.next.next; // slow moves 2 by 2.
+}
+----
+
+If the list has a loop, then at some point, both pointers will point to the same node. Take a look at the following image; take notice that both points to `node I` on the 8th iteration.
+
+image:cll-fast-slow-pointers.png[fast/slow pointer in a circular linked list]
+
+.You can detect the intersection point (`node D` on the example) by using this algorithm:
+- When `fast` and `slow` are the same, then create a (3rd) new pointer from the start.
+- Keep moving the 3rd pointer and the `slow` simultaneously one by one.
+- Where slow and 3rd pointer meets, that's the beginning of the loop or intersection (e.g., `node D`).
+
+Fast/slow pointer has essential properties, even if the list doesn't have a loop!
+
+If you don't have a loop, then fast and slow will never meet. However, by the time the `fast` pointer reaches the end, the `slow` pointer would be precisely in the middle!
+
+image:sll-fast-slow-pointers.png[fast/slow pointer in a singly linked list]
+
+This technique is useful for getting the middle element of a singly list in one pass without using any auxiliary data structure (like array or map).
+
+
+*LL-A*) _Find out if a linked list has a cycle and, if so, return the intersection node (where the cycle begins)._
+
+.Signature
+[source, javascript]
+----
+/**
+ * Find the node where the cycle begins or null.
+ * @param {Node} head
+ * @returns {Node|null}
+ */
+function findCycleStart(head) {
+
+};
+----
+
+.Examples
+[source, javascript]
+----
+findCycleStart(1 -> 2 -> 3); // null // no loops
+findCycleStart(1 -> 2 -> 3 -> *1); // 1 // node 3 loops back to 1
+findCycleStart(1 -> 2 -> 3 -> *2); // 2 // node 3 loops back to 2
+----
+
+*Solution*
+
+One solution is to find a loop using a HashMap (`Map`) or HashSet (`Set`) to track the visited nodes. If we found a node that is already on `Set`, then that's where the loop starts.
+
+.Solution 1: Map/Set for detecting loop
+[source, javascript]
+----
+include::../../interview-questions/linkedlist-find-cycle-start.js[tag=brute]
+----
+
+.Complexity Analysis
+- Time Complexity: `O(n)`. We might visit all nodes on the list (e.g., no loops).
+- Space complexity: `O(n)`. In the worst-case (no loop), we store all the nodes on the Set.
+
+Can we improve anything here? We can solve this problem without using any auxiliary data structure using the fast/slow pointer.
+
+.Solution 2: Fast/Slow pointer
+[source, javascript]
+----
+include::../../interview-questions/linkedlist-find-cycle-start.js[tag=fn]
+----
+
+
+.Complexity Analysis
+- Time Complexity: `O(n)`. In the worst case (no loop), we visit every node.
+- Space complexity: `O(1)`. We didn't use any auxiliary data structure.
+
+
+===== Multiple Pointers
+
+
+*LL-B*) _Determine if a singly linked list is a palindrome. A palindrome is a sequence that reads the same backward as forward._
+
+.Signature
+[source, javascript]
+----
+/**
+include::{codedir}/data-structures/linked-lists/node.js[tag=singly, indent=2]
+ */
+
+/**
+ * Determine if a list is a palindrome
+ * @param {Node} head
+ * @returns {boolean}
+ */
+function isPalindrome(head) {
+  // you code goes here!
+}
+----
+
+.Examples
+[source, javascript]
+----
+const toList = (arr) => new LinkedList(arr).first;
+isPalindrome(toList([1, 2, 3])); // false
+isPalindrome(toList([1, 2, 3, 2, 1])); // true
+isPalindrome(toList([1, 1, 2, 1])); // false
+isPalindrome(toList([1, 2, 2, 1])); // true
+----
+
+*Solution*
+
+To solve this problem, we have to check if the first and last node has the same value. Then we check if the second node and second last are the same, and so on. If we found any that's not equal; then it's not a palindrome. We can use two pointers, one at the start and the other at the end, and move them until they meet in the middle.
+
+The issue is that with a singly linked list, we can't move backward! We could either convert it into a doubly-linked list (with the last pointer) or copy the nodes into an array. Let's do the latter as a first approach.
+
+.Solution 1: List to array
+[source, javascript]
+----
+function isPalindrome(head) {
+  const arr = [];
+  for (let i = head; i; i = i.next) arr.push(i.value);
+  let lo = 0, hi = arr.length - 1;
+  while (lo < hi) if (arr[lo++] !== arr[hi++]) return false;
+  return true;
+}
+----
+
+What's the time complexity?
+
+.Complexity Analysis
+- Time Complexity: `O(n)`. We do two passes, one on the for-loop and the other in the array.
+- Space complexity: `O(n)`. We are using auxiliary storage with the array O(n).
+
+That's not bad, but can we do it without using any auxiliary data structure, O(1) space?
+
+.Here's another algorithm to solve this problem in O(1) space:
+- Find the middle node of the list (using fast/slow pointers).
+- Reverse the list from the middle to the end.
+- Have two new pointers, one at the beginning of the list and the other at the head of the reversed list.
+- If all nodes have the same value, then we have a palindrome, otherwise, we don't.
+
+.Solution 2: Reverse half of the list
+[source, javascript]
+----
+include::../../interview-questions/linkedlist-is-palindrome.js[tag=fn]
+----
+
+This solution is a little longer, but it's more space-efficient since it doesn't use any auxiliary data structure to hold the nodes.
+
+.Complexity Analysis
+- Time Complexity: `O(n)`. We visit every node once.
+- Space complexity: `O(1)`. We didn't use any auxiliary data structure. We changed data in-place.
+
+
+// https://leetcode.com/problems/remove-nth-node-from-end-of-list/
+
+// https://leetcode.com/problems/palindrome-linked-list/solution/
+
+
+===== Reverse a Linked List
+
+WIP
+// https://leetcode.com/problems/reverse-linked-list/
+
+// https://leetcode.com/problems/add-two-numbers-ii/
+
+===== Multi-level Linked Lists
+
+WIP
+// https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list/
+
+===== Intersections of linked lists
+
+WIP
+// https://leetcode.com/problems/intersection-of-two-linked-lists/
+
+// https://leetcode.com/problems/linked-list-cycle/
+
+
 ==== Practice Questions
 (((Interview Questions, Linked Lists)))
 

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 };

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);
+    });
+  });
+});

book/images/Words-Permutations.png

@@ -0,0 +1,28 @@
+// 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;
+      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[]
+
+module.exports = { isPalindrome };

book/images/cll-fast-slow-pointers.png

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