Implement Doubly Linked List exercise (#3)

* Copy doubly linked list skeleton into /src

* Update the find method in linked list exercise

* Make minor configuration updates

* Publish the initial doubly-linked list walkthrough

* Update the find method to accept a callback comparator

Author: Kevin K. Lee

.gitignore

@@ -1 +1,2 @@
 node_modules
+.vscode

assets/doubly-linked-list.png

@@ -13,7 +13,7 @@ module.exports = {
   coverageDirectory: './coverage/',
 
   // If the test path matches any of the patterns, it will be skipped.
-  testPathIgnorePatterns: ['<rootDir>/node_modules/', '/solutions'],
+  testPathIgnorePatterns: ['<rootDir>/node_modules/', '/solutions', '/skeletons'],
 
   // If the file path matches any of the patterns, coverage information will be skipped.
   coveragePathIgnorePatterns: ['<rootDir>/node_modules/'],

jest.config.js

@@ -1,11 +1,7 @@
 import DoublyLinkedListNode from './DoublyLinkedListNode';
-import Comparator from '../../utils/comparator/Comparator';
 
 export default class DoublyLinkedList {
-  /**
-   * @param {Function} [comparatorFunction]
-   */
-  constructor(comparatorFunction) {}
+  constructor() {}
 
   /**
    * @param {*} value
@@ -19,43 +15,43 @@ export default class DoublyLinkedList {
    */
   append(value) {}
 
-  /**
-   * @param {*} value
-   * @return {DoublyLinkedListNode}
-   */
-  delete(value) {}
-
   /**
    * @param {Object} findParams
    * @param {*} findParams.value
    * @param {function} [findParams.callback]
    * @return {DoublyLinkedListNode}
    */
   find({
-    value = undefined,
-    callback = undefined,
+    value,
+    callback
   }) {}
 
+  /**
+   * @return {DoublyLinkedListNode}
+   */
+  deleteHead() {}
+
   /**
    * @return {DoublyLinkedListNode}
    */
   deleteTail() {}
 
   /**
+   * @param {*} value
    * @return {DoublyLinkedListNode}
    */
-  deleteHead() {}
+  delete(value) {}
 
   /**
    * @return {DoublyLinkedListNode[]}
    */
   toArray() {
     const nodes = [];
+    let node = this.head;
 
-    let currentNode = this.head;
-    while (currentNode) {
-      nodes.push(currentNode);
-      currentNode = currentNode.next;
+    while (node) {
+      nodes.push(node);
+      node = node.next;
     }
 
     return nodes;
@@ -65,7 +61,7 @@ export default class DoublyLinkedList {
    * @param {function} [callback]
    * @return {string}
    */
-  toString(callback) {
-    return this.toArray().map(node => node.toString(callback)).toString();
+  toString() {
+    return this.toArray().map(node => node.toString()).toString();
   }
 }

skeletons/data-structures/doubly-linked-list/DoublyLinkedList.js

@@ -1,7 +1,9 @@
 export default class DoublyLinkedListNode {
-  constructor(value, next = null, previous = null) {}
+  constructor(value, next = null, previous = null) {
+    this.value = value;
+  }
 
-  toString(callback) {
-    return callback ? callback(this.value) : `${this.value}`;
+  toString() {
+    return this.value.toString();
   }
 }

skeletons/data-structures/doubly-linked-list/DoublyLinkedListNode.js

@@ -1,25 +1,79 @@
 # Doubly Linked List
 
-In computer science, a **doubly linked list** is a linked data structure that 
-consists of a set of sequentially linked records called nodes. Each node contains 
-two fields, called links, that are references to the previous and to the next 
-node in the sequence of nodes. The beginning and ending nodes' previous and next 
-links, respectively, point to some kind of terminator, typically a sentinel 
-node or null, to facilitate traversal of the list. If there is only one 
-sentinel node, then the list is circularly linked via the sentinel node. It can 
-be conceptualized as two singly linked lists formed from the same data items, 
-but in opposite sequential orders.
-
-![Doubly Linked List](https://upload.wikimedia.org/wikipedia/commons/5/5e/Doubly-linked-list.svg)
-
-The two node links allow traversal of the list in either direction. While adding 
-or removing a node in a doubly linked list requires changing more links than the 
-same operations on a singly linked list, the operations are simpler and 
-potentially more efficient (for nodes other than first nodes) because there 
-is no need to keep track of the previous node during traversal or no need 
-to traverse the list to find the previous node, so that its link can be modified.
-
-## References
-
-- [Wikipedia](https://en.wikipedia.org/wiki/Doubly_linked_list)
-- [YouTube](https://www.youtube.com/watch?v=JdQeNxWCguQ&t=7s&index=72&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+## Description
+
+Unlike a singly-linked list, a doubly-linked list node keeps a reference to the previous node in addition to the next node. This allows traversal in both directions of the list, towards the head and the tail.
+
+![Linked List](../../../assets/doubly-linked-list.png)
+
+The operations for the doubly linked list is the same a singly linked list.
+
+## Implementation
+
+In this exercise, implement the following functions for the `DoublyLinkedListNode` and `DoublyLinkedList` classes:
+
+- `DoublyLinkedListNode`
+  - `constructor()`
+    - Write a method that instantiates the node.
+    - The node takes `value`, `previous` 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.
+  - `find(value)`
+    - Write a method that returns the `node` that contains the `value`.
+  - `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.
+  - `delete(value)`
+    - Write a method that deletes the `value` 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
+
+To start, build `DoublyLinkedListNode`. A doubly linked list node keeps a reference to the previous node in addition to the next node. Then, build the constructor the same way as the singly linked list.
+
+> Jest Tip: If you need to filter by the exercise name, press `p`.
+> After pressing `p`, enter the string "Doubly" to filter by doubly linked list tests.
+
+### `prepend()`
+
+- The `prepend` method inserts the item at the beginning of the list.
+- Operations:
+  - Create a new `Node`.
+  - Set the current head's previous reference to the new node.
+  - Set the new node's next to the current `head`.
+  - Update `head` to point at the new node.
+- Take into consideration where this is the first value in the linked list.
+
+### `append()`
+
+- The `append` method inserts the item at the end of the list.
+- Operations:
+  - Create a new `Node`.
+  - Set the current tail's `next` to be the new node.
+  - Set the new node's previous to the current `tail`.
+  - Update `tail` to point at the new node.
+- Take into consideration where this is the first value in the linked list.
+
+### `find(value)`
+
+- The `find` method returns the node with the target value.
+- Traverse the array in the same way as a singly linked list.
+
+### `deleteHead()` / `deleteTail()`
+
+- The `deleteHead/Tail` methods are useful utilities methods.
+- Take into consideration where there is only one node in the linked list.
+
+### `delete(value)`
+
+- The `delete` method removes the first node with the specified value.
+- The delete operation for a doubly linked list is significantly simpler due to having a reference to the previous node.
+- Utilize `find` and `deleteHead/Tail` methods written above to write the method.

skeletons/data-structures/doubly-linked-list/README.md

@@ -36,17 +36,70 @@ describe('DoublyLinkedList', () => {
     expect(linkedList.toString()).toBe('3,2,1');
   });
 
+  it('should find node by value', () => {
+    const linkedList = new DoublyLinkedList();
+
+    expect(linkedList.find({
+      value: 5
+    })).toBeNull();
+
+    linkedList.append(1);
+    expect(linkedList.find({
+      value: 1
+    })).toBeDefined();
+
+    linkedList
+      .append(2)
+      .append(3);
+
+    const node = linkedList.find({
+      value: 2
+    });
+    expect(node.value).toBe(2);
+
+    expect(linkedList.find({
+      value: 5
+    })).toBeNull();
+  });
+
+  it('should find node by callback', () => {
+    const linkedList = new DoublyLinkedList();
+
+    linkedList
+      .append({
+        value: 1,
+        key: 'test1'
+      })
+      .append({
+        value: 2,
+        key: 'test2'
+      })
+      .append({
+        value: 3,
+        key: 'test3'
+      });
+
+    const node = linkedList.find({
+      callback: value => value.key === 'test2'
+    });
+
+    expect(node).toBeDefined();
+    expect(node.value.value).toBe(2);
+    expect(node.value.key).toBe('test2');
+
+    expect(linkedList.find({
+      callback: value => value.key === 'test5'
+    })).toBeNull();
+  });
+
   it('should delete node by value from linked list', () => {
     const linkedList = new DoublyLinkedList();
 
     expect(linkedList.delete(5)).toBeNull();
 
-    linkedList.append(1);
     linkedList.append(1);
     linkedList.append(2);
     linkedList.append(3);
-    linkedList.append(3);
-    linkedList.append(3);
     linkedList.append(4);
     linkedList.append(5);
 
@@ -55,11 +108,11 @@ describe('DoublyLinkedList', () => {
 
     const deletedNode = linkedList.delete(3);
     expect(deletedNode.value).toBe(3);
+    expect(linkedList.toString()).toBe('1,2,4,5');
     expect(linkedList.tail.previous.previous.value).toBe(2);
-    expect(linkedList.toString()).toBe('1,1,2,4,5');
 
     linkedList.delete(3);
-    expect(linkedList.toString()).toBe('1,1,2,4,5');
+    expect(linkedList.toString()).toBe('1,2,4,5');
 
     linkedList.delete(1);
     expect(linkedList.toString()).toBe('2,4,5');
@@ -146,79 +199,4 @@ describe('DoublyLinkedList', () => {
     expect(linkedList.head).toBeNull();
     expect(linkedList.tail).toBeNull();
   });
-
-  it('should be possible to store objects in the list and to print them out', () => {
-    const linkedList = new DoublyLinkedList();
-
-    const nodeValue1 = { value: 1, key: 'key1' };
-    const nodeValue2 = { value: 2, key: 'key2' };
-
-    linkedList
-      .append(nodeValue1)
-      .prepend(nodeValue2);
-
-    const nodeStringifier = value => `${value.key}:${value.value}`;
-
-    expect(linkedList.toString(nodeStringifier)).toBe('key2:2,key1:1');
-  });
-
-  it('should find node by value', () => {
-    const linkedList = new DoublyLinkedList();
-
-    expect(linkedList.find({ value: 5 })).toBeNull();
-
-    linkedList.append(1);
-    expect(linkedList.find({ value: 1 })).toBeDefined();
-
-    linkedList
-      .append(2)
-      .append(3);
-
-    const node = linkedList.find({ value: 2 });
-
-    expect(node.value).toBe(2);
-    expect(linkedList.find({ value: 5 })).toBeNull();
-  });
-
-  it('should find node by callback', () => {
-    const linkedList = new DoublyLinkedList();
-
-    linkedList
-      .append({ value: 1, key: 'test1' })
-      .append({ value: 2, key: 'test2' })
-      .append({ value: 3, key: 'test3' });
-
-    const node = linkedList.find({ callback: value => value.key === 'test2' });
-
-    expect(node).toBeDefined();
-    expect(node.value.value).toBe(2);
-    expect(node.value.key).toBe('test2');
-    expect(linkedList.find({ callback: value => value.key === 'test5' })).toBeNull();
-  });
-
-  it('should find node by means of custom compare function', () => {
-    const comparatorFunction = (a, b) => {
-      if (a.customValue === b.customValue) {
-        return 0;
-      }
-
-      return a.customValue < b.customValue ? -1 : 1;
-    };
-
-    const linkedList = new DoublyLinkedList(comparatorFunction);
-
-    linkedList
-      .append({ value: 1, customValue: 'test1' })
-      .append({ value: 2, customValue: 'test2' })
-      .append({ value: 3, customValue: 'test3' });
-
-    const node = linkedList.find({
-      value: { value: 2, customValue: 'test2' },
-    });
-
-    expect(node).toBeDefined();
-    expect(node.value.value).toBe(2);
-    expect(node.value.customValue).toBe('test2');
-    expect(linkedList.find({ value: 2, customValue: 'test5' })).toBeNull();
-  });
 });