Merge pull request #22 from datastructures-js/enhancements

Enhancements

Author: eyas-ranjous

.eslintrc

@@ -1,6 +1,6 @@
 {
   "rules": {
-    "max-len": ["error", { "code": 80, "ignoreComments": true }],
+    "max-len": ["error", { "code": 120, "ignoreComments": true }],
     "comma-dangle": ["error", {
       "functions": "ignore"
     }],

CHANGELOG.md

@@ -5,6 +5,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+## [5.2.0] - 2022-02-14
+### Added
+- `.find` now accepts a second param as the starting node in both types.
+- `.findReverse` added to DoublyLinkedList.
+- `.fromArray` static method added to both types.
+
 ## [5.1.1] - 2021-06-20
 ### Fixed
 - index.d.ts

DoublyLinkedList.md

@@ -13,7 +13,8 @@
   * [.insertAt(position, value)](#insertatposition-value)
   * [.forEach(cb)](#foreachcb)
   * [.forEachReverse(cb)](#foreachreversecb)
-  * [.find(cb)](#findcb)
+  * [.find(cb[, startingNode])](#findcb-startingnode)
+  * [.findReverse(cb[, startingNode])](#findreversecb-startingnode)
   * [.filter(cb)](#filtercb)
   * [.toArray()](#toarray)
   * [.isEmpty()](#isempty)
@@ -26,6 +27,7 @@
   * [.removeAt(position)](#removeatposition)
   * [.removeEach(cb)](#removeeachcb)
   * [.clear()](#clear)
+  * [DoublyLinkedList.fromArray(values)](#doublylinkedlistfromarrayvalues)
   * [DoublyLinkedListNode](#doublylinkedlistnode)
 * [Build](#build)
 * [License](#license)
@@ -198,8 +200,8 @@ doublyLinkedList.forEachReverse(
 */
 ```
 
-### .find(cb)
-Finds the first node that returns true from the callback or null if nothing found.
+### .find(cb[, startingNode])
+Finds the first node that returns true from the callback or null if nothing found. It accepts a second param as the starting node to search.
 
 <table>
   <tr>
@@ -208,8 +210,39 @@ Finds the first node that returns true from the callback or null if nothing foun
     <th align="center">runtime</th>
   </tr>
   <tr>
+    <td>
+      cb: (node: DoublyLinkedListNode&lt;T&gt;) => boolean
+      <br />
+      <i>startingNode: DoublyLinkedListNode&lt;T&gt;</i>
+    </td>
     <td align="center">
+      <a href="#doublylinkedlistnodet">DoublyLinkedListNode&lt;T&gt;</a>
+    </td>
+    <td align="center">O(n)</td>
+  </tr>
+</table>
+
+```js
+const node5 = doublyLinkedList.find(
+  (node, position) => node.getValue() === 5
+);
+console.log(node5.getValue()); // 5
+```
+
+### .findReverse(cb[, startingNode])
+Reversevly finds the first node that returns true from the callback or null if nothing found. It accepts a second param as the starting node to search.
+
+<table>
+  <tr>
+    <th align="center">params</th>
+    <th align="center">return</th>
+    <th align="center">runtime</th>
+  </tr>
+  <tr>
+    <td>
       cb: (node: DoublyLinkedListNode&lt;T&gt;) => boolean
+      <br />
+      <i>startingNode: DoublyLinkedListNode&lt;T&gt;</i>
     </td>
     <td align="center">
       <a href="#doublylinkedlistnodet">DoublyLinkedListNode&lt;T&gt;</a>
@@ -535,6 +568,19 @@ console.log(doublyLinkedList.head()); // null
 console.log(doublyLinkedList.tail()); // null
 ```
 
+### DoublyLinkedList.fromArray(values)
+creates a doubly linked list from an array.
+
+##### JS
+```js
+const dll = DoublyLinkedList.fromArray([1, 2, 3, 4, 5]);
+```
+
+##### TS
+```js
+const dll = DoublyLinkedList.fromArray<number>([1, 2, 3, 4, 5]);
+```
+
 ### DoublyLinkedListNode&lt;T&gt;
 
 #### new DoublyLinkedListNode&lt;T&gt;(value, prev, next)

LinkedList.md

@@ -12,7 +12,7 @@
   * [.insertLast(value[, startingNode])](#insertlastvalue-startingnode)
   * [.insertAt(position, value)](#insertatposition-value)
   * [.forEach(cb)](#foreachcb)
-  * [.find(cb)](#findcb)
+  * [.find(cb[, startingNode])](#findcb-startingnode)
   * [.filter(cb)](#filtercb)
   * [.toArray()](#toarray)
   * [.isEmpty()](#isempty)
@@ -23,6 +23,7 @@
   * [.removeAt(position)](#removeatposition)
   * [.removeEach(cb)](#removeeachcb)
   * [.clear()](#clear)
+  * [LinkedList.fromArray(values)](#linkedlistfromarrayvalues)
   * [LinkedListNode](#linkedlistnode)
 
 ## install
@@ -83,7 +84,7 @@ console.log(linkedList.insertFirst(1).getValue()); // 1
 ```
 
 ### .insertLast(value[, startingNode])
-inserts a node at the end of the list. it accepts an optional second param as the starting node which can be used to insert in O(1) runtime by passing in last inserted node.
+inserts a node at the end of the list. it accepts an optional second param as the starting node which can be used to insert in O(1) runtime.
 
 <table>
   <tr>
@@ -92,7 +93,11 @@ inserts a node at the end of the list. it accepts an optional second param as th
     <th align="center">runtime</th>
   </tr>
   <tr>
-    <td align="center">value: T</td>
+    <td>
+    value: T
+    <br />
+    <i>startingNode: LinkedListNode&lt;T&gt;</i>
+    </td>
     <td align="center"><a href="#linkedlistnodet">LinkedListNode&lt;T&gt;</a></td>
     <td>
       O(n) | O(1) with last inserted node passed
@@ -167,8 +172,8 @@ linkedList.forEach(
 */
 ```
 
-### .find(cb)
-finds the first node that returns true from the callback or null if nothing found.
+### .find(cb[, startingNode])
+finds the first node that returns true from the callback or null if nothing found. It accepts a second param as the starting node to search.
 
 <table>
   <tr>
@@ -177,8 +182,10 @@ finds the first node that returns true from the callback or null if nothing foun
     <th align="center">runtime</th>
   </tr>
   <tr>
-    <td align="center">
+    <td>
       cb: (node: LinkedListNode&lt;T&gt;) => boolean
+      <br />
+      <i>startingNode: LinkedListNode&lt;T&gt;</i>
     </td>
     <td align="center"><a href="#linkedlistnodet">LinkedListNode&lt;T&gt;</a></td>
     <td align="center">O(n)</td>
@@ -407,6 +414,19 @@ console.log(linkedList.count()); // 0
 console.log(linkedList.head()); // null
 ```
 
+### LinkedList.fromArray(values)
+creates a linked list from an array.
+
+##### JS
+```js
+const ll = LinkedList.fromArray([1, 2, 3, 4, 5]);
+```
+
+##### TS
+```js
+const ll = LinkedList.fromArray<number>([1, 2, 3, 4, 5]);
+```
+
 ### LinkedListNode&lt;T&gt;
 
 #### new LinkedListNode&lt;T&gt;(value, next)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datastructures-js/linked-list",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "description": "a javascript implementation of LinkedList & DoublyLinkedList",
   "main": "index.js",
   "scripts": {
@@ -35,8 +35,5 @@
     "grunt-mocha-test": "^0.13.3",
     "istanbul": "^0.4.5",
     "mocha": "^6.2.2"
-  },
-  "dependencies": {
-    "@datastructures-js/binary-search-tree": "^4.1.0"
   }
 }

src/doublyLinkedList.d.ts

@@ -12,12 +12,14 @@ export class DoublyLinkedList<T> {
   removeEach(cb: (node: DoublyLinkedListNode<T>, position: number) => boolean): number;
   forEach(cb: (node: DoublyLinkedListNode<T>, position: number) => void): void;
   forEachReverse(cb: (node: DoublyLinkedListNode<T>, position: number) => void): void;
-  find(cb: (node: DoublyLinkedListNode<T>) => boolean): DoublyLinkedListNode<T>;
+  find(cb: (node: DoublyLinkedListNode<T>, startingNode?: DoublyLinkedListNode<T>) => boolean): DoublyLinkedListNode<T>;
+  findReverse(cb: (node: DoublyLinkedListNode<T>, startingNode?: DoublyLinkedListNode<T>) => boolean): DoublyLinkedListNode<T>;
   filter(cb: (node: DoublyLinkedListNode<T>, position: number) => boolean): DoublyLinkedList<T>;
   head(): DoublyLinkedListNode<T>;
   tail(): DoublyLinkedListNode<T>;
   count(): number;
   toArray(): T[];
   isEmpty(): boolean;
   clear(): void;
+  static fromArray<T>(values: T[]): DoublyLinkedList<T>;
 }

src/doublyLinkedList.js

@@ -267,14 +267,19 @@ class DoublyLinkedList {
    * Finds a node in the list using a callback
    * @public
    * @param {function} cb
+   * @param {DoublyLinkedListNode} [startingNode]
    * @returns {DoublyLinkedListNode}
    */
-  find(cb) {
+  find(cb, startingNode = this._head) {
     if (typeof cb !== 'function') {
       throw new Error('.find(cb) expects a callback');
     }
 
-    let current = this._head;
+    if (startingNode && !(startingNode instanceof DoublyLinkedListNode)) {
+      throw new Error('.find(cb) expects to start from a DoublyLinkedListNode');
+    }
+
+    let current = startingNode;
     while (current instanceof DoublyLinkedListNode) {
       if (cb(current)) {
         return current;
@@ -284,6 +289,32 @@ class DoublyLinkedList {
     return null;
   }
 
+  /**
+   * Finds a node in the list using a callback in reverse order
+   * @public
+   * @param {function} cb
+   * @param {DoublyLinkedListNode} [startingNode]
+   * @returns {DoublyLinkedListNode}
+   */
+  findReverse(cb, startingNode = this._tail) {
+    if (typeof cb !== 'function') {
+      throw new Error('.findReverse(cb) expects a callback');
+    }
+
+    if (startingNode && !(startingNode instanceof DoublyLinkedListNode)) {
+      throw new Error('.findReverse(cb) expects to start from a DoublyLinkedListNode');
+    }
+
+    let current = startingNode;
+    while (current instanceof DoublyLinkedListNode) {
+      if (cb(current)) {
+        return current;
+      }
+      current = current.getPrev();
+    }
+    return null;
+  }
+
   /**
    * Filters the list based on a callback.
    * @public
@@ -359,6 +390,25 @@ class DoublyLinkedList {
     this._tail = null;
     this._count = 0;
   }
+
+  /**
+   * Creates a doubly linked list from an array
+   * @public
+   * @static
+   * @param {array} values
+   * @return {DoublyLinkedList}
+   */
+  static fromArray(values) {
+    if (!Array.isArray(values)) {
+      throw new Error('cannot create DoublyLinkedList from none-array values');
+    }
+
+    const doublyLinkedList = new DoublyLinkedList();
+    values.forEach((value) => {
+      doublyLinkedList.insertLast(value);
+    });
+    return doublyLinkedList;
+  }
 }
 
 exports.DoublyLinkedList = DoublyLinkedList;

src/linkedList.d.ts

@@ -17,4 +17,5 @@ export class LinkedList<T> {
   toArray(): T[];
   isEmpty(): boolean;
   clear(): void;
+  static fromArray<T>(values: T[]): LinkedList<T>;
 }

src/linkedList.js

@@ -211,14 +211,20 @@ class LinkedList {
   /**
    * Finds one node in the list based on a callback.
    * @public
+   * @param {function} cb
+   * @param {DoublyLinkedListNode} [startingNode]
    * @returns {LinkedListNode}
    */
-  find(cb) {
+  find(cb, startingNode = this._head) {
     if (typeof cb !== 'function') {
       throw new Error('.find(cb) expects a callback');
     }
 
-    let current = this._head;
+    if (startingNode && !(startingNode instanceof LinkedListNode)) {
+      throw new Error('.find(cb) expects to start from a LinkedListNode');
+    }
+
+    let current = startingNode;
     while (current instanceof LinkedListNode) {
       if (cb(current)) {
         return current;
@@ -294,6 +300,26 @@ class LinkedList {
     this._head = null;
     this._count = 0;
   }
+
+  /**
+   * Creates a linked list from an array
+   * @public
+   * @static
+   * @param {array} values
+   * @return {LinkedList}
+   */
+  static fromArray(values) {
+    if (!Array.isArray(values)) {
+      throw new Error('cannot create LinkedList from none-array values');
+    }
+
+    const linkedList = new LinkedList();
+    let lastInserted = null;
+    values.forEach((value) => {
+      lastInserted = linkedList.insertLast(value, lastInserted);
+    });
+    return linkedList;
+  }
 }
 
 exports.LinkedList = LinkedList;