Implement Linked List exercise (#2)

* Update LinkedList skeleton, solution and tests

* Remove the Comparator helper

* Publish the initial LinkedList walkthrough draft

* Utilize README in /solutions folder

* Make correction for node removal in linked list

* Add possible curriculum schedules

* Add the linked list walkthrough to /skeletons and /src folders

Author: Kevin K. Lee

README.md

@@ -44,7 +44,64 @@ The problem sets below contain information on key data structures, sorting/searc
 
 ### Schedule
 
-The plan is to meet in #algorithms-curriculum channel on [Operation Code Slack](https://operationcode.org), and solve one or two exercises a week. The curriculum will reset and restart after solving every exercise. The exercises will be in increasing difficulty, and though you can jump in and out, be aware that some are built on top of previously built data structures.
+These schedules are guidelines.  Please approach them at your own pace.
+
+#### Regular
+Recommended track for beginners who can devote 2-4 hours a day.
+
+* Day 1
+  - Queue (1 Hour)
+  - Stack (1 Hour)
+* Day 2
+  - Linked List (4 Hours)
+* Day 3
+  - Hash Table (4 Hours)
+* Day 4
+  - Selection Sort (30 Minutes)
+  - Insertion Sort (30 Minutes)
+  - Bubble Sort (2 Hours)
+* Day 5
+  - Merge Sort (4 Hours)
+* Day 6
+  - Quicksort (4 Hours)
+* Day 6
+  - Binary Search  (2 Hours)
+* Day 7
+  - Depth-First Search (2 Hour)
+* Day 8
+  - Breadth-First Search (2 Hour)
+* Day 9
+  - Binary Search Tree (4 Hours)
+* Day 10
+  - Binary Search Tree (4 Hours)
+* Day 11
+  - Fibonacci Number (1 Hour)
+  - Prime Number (1 Hour)
+  - Factorial (2 Hours)
+
+#### Quick
+Recommended for someone who is comfortable coding and can devote ~6 hours a day.
+
+* Day 1
+  - Queue (30 Minutes)
+  - Stack (30 Minutes)
+  - Linked List (2 Hours)
+  - Hash Table (2 Hours)
+* Day 2
+  - Selection Sort (30 Minutes)
+  - Insertion Sort (30 Minutes)
+  - Bubble Sort (1 Hour)
+  - Merge Sort (4 Hours)
+  - Quicksort (2 Hours)
+* Day 3
+  - Binary Search (1 Hour)
+  - Depth-First Search (1 Hour)
+  - Breadth-First Search (1 Hour)
+  - Factorial (30 Minutes)
+  - Fibonacci Number (1 Hour)
+  - Prime Number (1 Hour)
+* Day 4
+  - Binary Search Tree (6 Hours)
 
 ### Folders
 

assets/linked-list-delete.png

@@ -1,25 +1,148 @@
 # Linked List
 
-In computer science, a linked list is a linear collection 
-of data elements, in which linear order is not given by 
-their physical placement in memory. Instead, each 
-element points to the next. It is a data structure 
-consisting of a group of nodes which together represent 
-a sequence. Under the simplest form, each node is 
-composed of data and a reference (in other words, 
-a link) to the next node in the sequence. This structure
-allows for efficient insertion or removal of elements 
-from any position in the sequence during iteration. 
-More complex variants add additional links, allowing 
-efficient insertion or removal from arbitrary element 
-references. A drawback of linked lists is that access 
-time is linear (and difficult to pipeline). Faster 
-access, such as random access, is not feasible. Arrays 
-have better cache locality as compared to linked lists.
-
-![Linked List](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
-
-## References
-
-- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)
-- [YouTube](https://www.youtube.com/watch?v=njTh_OwMljA&index=2&t=1s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+## Description
+
+A linked list is a linear colletion of elements _in sequential order_. Imagine a chain, with a start and a end, with the chain links connected to each other. A linked list can be visualized as below:
+
+![Linked List](../../../assets/linked-list-overview.png)
+
+A linked list is composed of a smaller data structure usually called a `Node`. The node object contains the `value` of the element itself, and also a pointer to the `next` node in the chain. By utilizing `node.next`, you can traverse the list. The beginning of a linked list is denoted with `head` and the last element is `tail`.
+
+In a singly-linked list, the link is established in _one direction_ only, where the node only keeps track of the next node in the chain. This means that with a singly-linked list, you can only traverse in the direction of the tail. On the other hand, a node in a doubly-linked list keeps track of both `next` and `previous` which allows you to traverse in both directions (towards `head` and `tail`).
+
+## Implementation
+
+In this exercise, implement the following functions for the `LinkedListNode` and `LinkedList` classes:
+
+- `LinkedListNode`
+  - `constructor()`
+    - Write a method that instantiates the node.
+    - The node takes `value` and `next`.
+- `LinkedList`
+  - `constructor()`
+    - Write a method that instantiates the list.
+    - The instance variables `head` and `tail` should be set to `null`.
+  - `prepend(value)`
+    - Write a method that inserts the `value` at the beginning of the linked list.
+  - `append(value)`
+    - Write a method that inserts the `value` at the end of the linked list.
+  - `delete(value)`
+    - Write a method that deletes the `value` in the linked list.
+  - `find({ value })`
+    - Write a method that returns the `node` that contains the `value`.
+  - `insertAfter(value, targetValue)`
+    - Write a method that inserts the `node` after the `node` that contains the `targetValue`.
+  - `deleteHead()`
+    - Write a method that deletes the first element in the linked list.
+  - `deleteTail()`
+    - Write a method that deletes the last element in the linked list.
+
+The most important operations are `prepend/append` for adding data, `delete` for removing data, and `find` for retrieving data.
+
+## Detailed Walkthrough
+
+Let's start by opening up a terminal window and running `npm run watch`. This will start our TDD framework that will automatically re-run the tests when you save any changes to your file.
+
+* In your code editor, navigate to `/algorithms/src/data-structures/LinkedListNode.js`.
+* In the constructor method, write `this.value = value` and save the changes.
+* You will see the tests run automatically in your terminal:
+
+![Jest TDD Console Outputs](../../../assets/linked-list-tdd.png)
+
+> Jest Tip: If you need to filter by the exercise name, press `p`.
+> (press `w` for the list of available commands).
+
+The output tells you that three tests are failing:
+* ✕ should create list node with value (10ms)
+* ✕ should create list node with object as a value (2ms)
+* ✕ should link nodes together
+* ✓ should convert node to string
+* ✓ should convert node to string with custom stringifier (1ms)
+
+The code for the last two tests (`toString()` tests) have been provided for you in the skeleton.  Your task is to make the three failing tests to pass.
+
+### `LinkedListNode`
+* The test description says `› should create list node with value`
+* The output tells us where the test is failing: `expect(node.next).toBeNull();`. It also tells us `expect(received).toBeNull()` and `Received: undefined`.
+* In this case, the test is `expect`ing `node.next` to be `null`. However, the test received  `undefined`.
+* Since `next` is undefined, let's update our `constructor()` in `LinkedListNode.js`:
+  ```
+  constructor(value, next = null) {
+    this.value = value;
+    this.next = next;
+  }
+  ```
+* When you save the file, you should see all your tests for `LinkedListNode` pass!
+* Often, many tests can depend on the same part of the code.  In this case, solving for one test case solved all others.
+
+Now, let's open up `LinkedList.js` in our editor.
+
+### `constructor()`
+* A linked list should always have a `head` and a `tail`.
+* The test tells us: `expect(linkedList.head).toBeNull();`. Let's create the instance variables:
+  ```
+  constructor() {
+    this.head = null;
+    this.tail = null;
+  }
+  ```
+
+### `prepend()`
+* The `prepend` method inserts the item at the beginning of the list.
+* Prepending an item is a simple operation:
+  * Create a new `Node`.
+  * Set the new `node`'s `next to be the current head node.
+  * Update the `head` to point at the new node.
+* We also have to consider a case where this is the first item stored in the list.  In that case, we also set the tail to the same node.
+
+### `append()`
+* The `append` method inserts the item at the end of the list.
+* Operations:
+  * Create a new `Node`.
+  * Set the tail's `next` to be the new node.
+  * Update `tail` to point at the new node.
+* Again, take into consideration when this is the first item stored in the list.
+
+### `find({ value })`
+* The `find` method returns the node with the target value.
+* A node can be visited by utilizing a loop and `node.next`.
+* The following snippet traverses the entire list:
+  ```
+  let currentNode = node;
+
+  while (currentNode.next) {
+    currentNode = node.next
+    console.log(currentNode.value)
+  }
+  ```
+* Think about how the above concept can be applied to find the target node.
+
+### `insertAfter(value, insertValue)`
+* The `insertAfter` method stores the `insertValue` right after the node with the `value`.
+* Operation:
+  ![Linked List Delete Operation](../../../assets/linked-list-insert-after.png)
+  * Create a new `Node`.
+  * Find the node with the target value.
+  * Set the found node's `next` to the new node.
+  * Set new node's `next` to the found node's `next.
+* Utilize the previously written `find` method to find the node.
+
+### `delete(value)`
+* The `delete` method removes the first node with the specified value.
+* Operations:
+  ![Linked List Delete Operation](../../../assets/linked-list-delete.png)
+  * Traverse the list and locate the node before the target node.
+  * Remove the target node that is placed after the found node.
+    * In a linked list, you don't have to delete the actual node.
+    * Deleting means removing the reference to that node from the list.
+    * The above diagram shows that all we have to do is set the target node's previous node's `next` to point at the target node's `next`.
+    * This means that we must locate the node right before the target node.  Think about how you would be able to tell when the next node will be the target node.
+  * Also, take into consideration if the `head` or `tail` node is the node to be deleted.
+* This is the most complex operation in a linked list.  Drawing the operation on paper can help you visualize the problem.  Don't hesitate to reach out to #basic-algorithms channel on Slack if you are stuck.
+
+### `deleteHead()` / `deleteTail()`
+* The `deleteHead/Tail` methods are utility methods for common operations.
+
+## Time and Space Complexity Analysis
+
+This section will be released in the future when the Big O notation tutorials are written.  Please join #basic-algorithms channel for the update notifications.

assets/linked-list-insert-after.png

@@ -1,18 +1,9 @@
 import LinkedListNode from './LinkedListNode';
-import Comparator from '../../utils/comparator/Comparator';
 
 export default class LinkedList {
-  /**
-   * @param {Function} [comparatorFunction]
-   */
-  constructor(comparatorFunction) {
-    /** @var LinkedListNode */
+  constructor() {
     this.head = null;
-
-    /** @var LinkedListNode */
     this.tail = null;
-
-    this.compare = new Comparator(comparatorFunction);
   }
 
   /**
@@ -66,7 +57,7 @@ export default class LinkedList {
     let deletedNode = null;
 
     // If the head must be deleted then make 2nd node to be a head.
-    while (this.head && this.compare.equal(this.head.value, value)) {
+    while (this.head && this.head.value === value) {
       deletedNode = this.head;
       this.head = this.head.next;
     }
@@ -76,7 +67,7 @@ export default class LinkedList {
     if (currentNode !== null) {
       // If next node must be deleted then make next node to be a next next one.
       while (currentNode.next) {
-        if (this.compare.equal(currentNode.next.value, value)) {
+        if (currentNode.next.value === value) {
           deletedNode = currentNode.next;
           currentNode.next = currentNode.next.next;
         } else {
@@ -86,7 +77,7 @@ export default class LinkedList {
     }
 
     // Check if tail must be deleted.
-    if (this.compare.equal(this.tail.value, value)) {
+    if (this.tail.value === value) {
       this.tail = currentNode;
     }
 
@@ -96,24 +87,17 @@ export default class LinkedList {
   /**
    * @param {Object} findParams
    * @param {*} findParams.value
-   * @param {function} [findParams.callback]
    * @return {LinkedListNode}
    */
-  find({ value = undefined, callback = undefined }) {
+  find({ value  }) {
     if (!this.head) {
       return null;
     }
 
     let currentNode = this.head;
 
     while (currentNode) {
-      // If callback is specified then try to find node by callback.
-      if (callback && callback(currentNode.value)) {
-        return currentNode;
-      }
-
-      // If value is specified then try to compare by value..
-      if (value !== undefined && this.compare.equal(currentNode.value, value)) {
+      if (value === currentNode.value) {
         return currentNode;
       }
 
@@ -123,12 +107,24 @@ export default class LinkedList {
     return null;
   }
 
+    /**
+   * @param {*} value
+   * @return {LinkedList}
+   */
+  insertAfter(value, insertValue) {
+    const targetNode = this.find({ value: insertValue });
+    const newNode = new LinkedListNode(value, targetNode.next);
+
+    targetNode.next = newNode;
+    return newNode;
+  }
+
   /**
    * @return {LinkedListNode}
    */
   deleteTail() {
+    // There is only one node in linked list.
     if (this.head === this.tail) {
-      // There is only one node in linked list.
       const deletedTail = this.tail;
       this.head = null;
       this.tail = null;
@@ -141,6 +137,7 @@ export default class LinkedList {
 
     // Rewind to the last node and delete "next" link for the node before the last one.
     let currentNode = this.head;
+
     while (currentNode.next) {
       if (!currentNode.next.next) {
         currentNode.next = null;
@@ -179,8 +176,8 @@ export default class LinkedList {
    */
   toArray() {
     const nodes = [];
-
     let currentNode = this.head;
+
     while (currentNode) {
       nodes.push(currentNode);
       currentNode = currentNode.next;