feat: add DoublyLInkedList (#21)

Author: mg901

.husky/pre-commit

@@ -0,0 +1,5 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+bun prettify
+bun lint

.husky/pre-push

@@ -2,4 +2,3 @@
 . "$(dirname -- "$0")/_/husky.sh"
 
 bun test
-bun lint

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "cSpell.words": ["isequal"]
+}

bun.lockb

@@ -1,3 +1,3 @@
-module.exports =  {
+module.exports = {
   extends: ['@commitlint/config-conventional'],
-};
+};

commitlint.config.cjs

@@ -0,0 +1,3 @@
+module.exports = {
+  '**/*': ['eslint . --fix --ext .ts', 'prettier --write --ignore-unknown'],
+};

lint-staged.config.cjs

@@ -1,31 +1,39 @@
 {
   "name": "js-data-structures-implementation",
-  "module": "src/index.ts",
+  "type": "module",
+  "exports": "./src/index.ts",
   "scripts": {
     "start": "bun run src/index.ts",
     "commit": "cz",
     "lint": "eslint . --fix --ext .ts",
-    "test": "bun vitest",
-    "test:watch": "bun vitest --watch",
+    "test": "bun vitest run",
+    "test:watch": "bun vitest",
+    "prettify": "npx prettier . --write --ignore-unknown",
     "prepare": "husky install"
   },
   "devDependencies": {
     "@commitlint/cli": "^18.4.3",
     "@commitlint/config-conventional": "^18.4.3",
+    "@types/lodash.isequal": "^4.5.8",
     "@typescript-eslint/eslint-plugin": "^6.12.0",
     "@typescript-eslint/parser": "^6.12.0",
     "bun-types": "^1.0.14",
     "commitizen": "^4.3.0",
+    "cz-conventional-changelog": "^3.3.0",
     "eslint": "^8.54.0",
     "eslint-config-airbnb-typescript": "^17.1.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-jest": "^27.6.0",
     "eslint-plugin-prettier": "^5.0.1",
     "git-cz": "^4.9.0",
     "husky": "^8.0.3",
+    "prettier": "^3.1.0",
     "vitest": "^0.34.6"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "lodash.isequal": "^4.5.0"
   }
 }

package.json

@@ -3,13 +3,13 @@ import { DoublyLinkedListNode } from './doubly-linked-list-node';
 
 describe('DoublyLinkedListNode', () => {
   it('creates list node with value', () => {
-    // Arrange
-    const list = new DoublyLinkedListNode<number>(1);
+    // Act
+    const doublyList = new DoublyLinkedListNode<number>(1);
 
-    // Act with Assert
-    expect(list.value).toBe(1);
-    expect(list.next).toBeNull();
-    expect(list.prev).toBeNull();
+    // Assert
+    expect(doublyList.value).toBe(1);
+    expect(doublyList.next).toBeNull();
+    expect(doublyList.prev).toBeNull();
   });
 
   it('creates list node with object with value', () => {
@@ -19,8 +19,10 @@ describe('DoublyLinkedListNode', () => {
       key: 'test',
     };
 
+    // Act
     const list = new DoublyLinkedListNode<typeof expectedValue>(expectedValue);
 
+    // Assert
     expect(list.value).toEqual(expectedValue);
     expect(list.next).toBeNull();
     expect(list.prev).toBeNull();
@@ -29,10 +31,14 @@ describe('DoublyLinkedListNode', () => {
   it('links node together', () => {
     // Arrange
     const node2 = new DoublyLinkedListNode<number>(2);
+
+    // Act
     const node1 = new DoublyLinkedListNode<number>(1, node2);
+
+    // Act
     const node3 = new DoublyLinkedListNode<number>(3, node1, node2);
 
-    // Act and Assert
+    // Assert
     expect(node1.next).toBeDefined();
     expect(node1.prev).toBeNull();
     expect(node2.next).toBeNull();
@@ -49,14 +55,8 @@ describe('DoublyLinkedListNode', () => {
     // Arrange
     const list = new DoublyLinkedListNode<number>(1);
 
-    // Assert
+    // Act and Assert
     expect(list.toString()).toBe('1');
-
-    // Act
-    list.value = 2;
-
-    // Assert
-    expect(list.toString()).toBe('2');
   });
 
   it('converts node to string with custom stringifier', () => {
@@ -67,11 +67,13 @@ describe('DoublyLinkedListNode', () => {
     };
 
     const list = new DoublyLinkedListNode<typeof nodeValue>(nodeValue);
-
     const toStringCallback = (x: typeof nodeValue) =>
       `value: ${x.value}, key: ${x.key}`;
 
-    // Act and Assert
-    expect(list.toString(toStringCallback)).toBe('value: 1, key: test');
+    // Act
+    const received = list.toString(toStringCallback);
+
+    // Assert
+    expect(received).toBe('value: 1, key: test');
   });
 });

src/doubly-linked-list/doubly-linked-list-node.spec.ts

@@ -1,14 +1,32 @@
 import { DoublyLinkedListNode } from './doubly-linked-list-node';
+import { Comparator } from '../utils/comparator';
+import type { IComparator, CompareFunction } from '../utils/comparator';
 
-type NullableDoublyLinkedListNode<T> = DoublyLinkedListNode<T> | null;
+type NullableDoublyLinkedListNode<T = any> = DoublyLinkedListNode<T> | null;
+
+type FindMethodOptions<T = any> = {
+  value?: T;
+  predicate?: (value: T) => boolean;
+};
 
 export interface IDoublyLinkedList<T = any> {
   readonly head: NullableDoublyLinkedListNode<T>;
   readonly tail: NullableDoublyLinkedListNode<T>;
   readonly length: number;
+  readonly isEmpty: boolean;
+
   append(value: T): this;
+  fromArray(array: T[]): this;
   toArray(): T[];
   toString(): string;
+  prepend(value: T): this;
+  delete(value: T): NullableDoublyLinkedListNode<T>;
+  reverse(): this;
+  insertAt(index: number, value: T): this;
+  deleteHead(): NullableDoublyLinkedListNode<T>;
+  deleteTail(): NullableDoublyLinkedListNode<T>;
+  indexOf(value: T): number;
+  find(options: FindMethodOptions<T>): NullableDoublyLinkedListNode<T>;
 }
 
 export class DoublyLinkedList<T = any> implements IDoublyLinkedList<T> {
@@ -18,10 +36,13 @@ export class DoublyLinkedList<T = any> implements IDoublyLinkedList<T> {
 
   #length: number;
 
-  constructor() {
+  #compare: IComparator<T>;
+
+  constructor(compareFunction?: CompareFunction<T>) {
     this.#head = null;
     this.#tail = null;
     this.#length = 0;
+    this.#compare = new Comparator(compareFunction);
   }
 
   get head() {
@@ -36,15 +57,19 @@ export class DoublyLinkedList<T = any> implements IDoublyLinkedList<T> {
     return this.#length;
   }
 
+  get isEmpty() {
+    return this.#head === null;
+  }
+
   append(value: T) {
     const newNode = new DoublyLinkedListNode(value);
 
     if (this.#head === null) {
       this.#head = newNode;
       this.#tail = newNode;
     } else {
-      this.#tail!.next = newNode;
       newNode.prev = this.#tail;
+      this.#tail!.next = newNode;
       this.#tail = newNode;
     }
 
@@ -53,6 +78,14 @@ export class DoublyLinkedList<T = any> implements IDoublyLinkedList<T> {
     return this;
   }
 
+  fromArray(array: T[]) {
+    array.forEach((value) => {
+      this.append(value);
+    });
+
+    return this;
+  }
+
   toArray() {
     let array = [];
     let currentNode = this.#head;
@@ -68,4 +101,208 @@ export class DoublyLinkedList<T = any> implements IDoublyLinkedList<T> {
   toString() {
     return this.toArray().toString();
   }
+
+  prepend(value: T) {
+    const newNode = new DoublyLinkedListNode(value);
+
+    if (this.#head === null) {
+      this.#head = newNode;
+      this.#tail = newNode;
+    } else {
+      newNode.next = this.#head;
+      this.#head.prev = newNode;
+      this.#head = newNode;
+    }
+
+    this.#length += 1;
+
+    return this;
+  }
+
+  delete(value: T) {
+    if (this.#head === null) return null;
+
+    let deletedNode = null as NullableDoublyLinkedListNode;
+
+    // Delete from the beginning of the list.
+    if (this.#compare.equal(value, this.#head.value)) {
+      deletedNode = this.#head;
+      this.#head = deletedNode.next;
+
+      // Update tail if the list becomes empty.
+      if (this.#head === null) {
+        this.#tail = null;
+      } else {
+        this.#head.prev = null;
+      }
+    } else {
+      let currentNode = this.#head;
+
+      // Search for the node by value.
+      while (
+        currentNode.next &&
+        !this.#compare.equal(value, currentNode.next.value)
+      ) {
+        currentNode = currentNode.next;
+      }
+
+      // Delete the node from the middle.
+      if (currentNode.next !== null) {
+        deletedNode = currentNode.next;
+        currentNode.next = deletedNode.next;
+
+        if (currentNode.next === null) {
+          this.#tail = currentNode;
+        } else {
+          currentNode.next.prev = currentNode;
+        }
+      }
+    }
+
+    if (deletedNode) {
+      this.#length -= 1;
+    }
+
+    return deletedNode;
+  }
+
+  reverse() {
+    if (this.#head === null || this.#head.next === null) {
+      return this;
+    }
+
+    let prevNode = null;
+    let currentNode = this.#head as NullableDoublyLinkedListNode;
+
+    while (currentNode !== null) {
+      const nextNode = currentNode.next;
+      currentNode.next = prevNode;
+      currentNode.prev = nextNode;
+      prevNode = currentNode;
+
+      currentNode = nextNode;
+    }
+
+    this.#tail = this.#head;
+    this.#head = prevNode;
+
+    return this;
+  }
+
+  #findNodeByIndex(index: number) {
+    let currentNode = this.#head!;
+
+    for (let i = 0; i < index; i += 1) {
+      currentNode = currentNode.next!;
+    }
+
+    return currentNode;
+  }
+
+  insertAt(index: number, value: T) {
+    const isInvalidIndex = index < 0 || index > this.#length;
+
+    if (isInvalidIndex) {
+      throw new Error(
+        'Index should be greater than or equal to 0 and less than or equal to the list length.',
+      );
+    }
+
+    if (index === 0) {
+      // Insert at the beginning.
+      this.prepend(value);
+      // Insert at the end.
+    } else if (index === this.#length) {
+      this.append(value);
+    } else {
+      // Insert in the middle.
+      let prevNode = this.#findNodeByIndex(index - 1);
+      let newNode = new DoublyLinkedListNode(value);
+      newNode.next = prevNode.next;
+      newNode.prev = prevNode;
+      prevNode.next = newNode;
+
+      this.#length += 1;
+    }
+
+    return this;
+  }
+
+  deleteHead() {
+    if (this.#head === null) return null;
+
+    const deletedNode = this.#head;
+
+    if (deletedNode?.next) {
+      this.#head = deletedNode.next;
+      this.#head.prev = null;
+    } else {
+      this.#head = null;
+      this.#tail = null;
+    }
+
+    this.#length -= 1;
+
+    return deletedNode;
+  }
+
+  deleteTail() {
+    if (this.#head === null) return null;
+
+    let deletedNode = this.#tail;
+
+    // If there is only one node.
+    if (this.#head === this.#tail) {
+      this.#head = null;
+      this.#tail = null;
+    } else {
+      // If multiple nodes.
+      let currentNode = this.#head;
+
+      while (currentNode.next?.next) {
+        currentNode = currentNode.next;
+      }
+
+      currentNode.next = null;
+      this.#tail = currentNode;
+    }
+
+    this.#length -= 1;
+
+    return deletedNode;
+  }
+
+  indexOf(value: T) {
+    let count = 0;
+    let currentNode = this.#head;
+
+    while (currentNode !== null) {
+      if (this.#compare.equal(value, currentNode.value)) return count;
+
+      currentNode = currentNode.next;
+      count += 1;
+    }
+
+    return -1;
+  }
+
+  find({ value, predicate }: FindMethodOptions<T>) {
+    if (this.#head === null) return null;
+
+    let currentNode = this.#head as NullableDoublyLinkedListNode;
+
+    while (currentNode) {
+      if (predicate && predicate(currentNode.value)) {
+        return currentNode;
+      }
+
+      if (value && this.#compare.equal(value, currentNode.value)) {
+        return currentNode;
+      }
+
+      currentNode = currentNode.next;
+    }
+
+    return null;
+  }
 }

src/doubly-linked-list/doubly-linked-list.spec.ts

@@ -28,8 +28,10 @@ describe('LinkedListNode', () => {
   });
 
   it('links nodes together', () => {
-    // Arrange and Act
+    // Arrange
     const node2 = new LinkedListNode<number>(1);
+
+    // Act
     const node1 = new LinkedListNode<number>(2, node2);
 
     // Assert
@@ -43,13 +45,9 @@ describe('LinkedListNode', () => {
     it('converts node to string', () => {
       // Arrange
       const node = new LinkedListNode<number>(1);
-      expect(node.toString()).toEqual('1');
-
-      // Act
-      node.value = 2;
 
-      // Assert
-      expect(node.toString()).toEqual('2');
+      // Act and Assert
+      expect(node.toString()).toEqual('1');
     });
 
     it('converts node to string with custom stringifier', () => {
@@ -63,7 +61,11 @@ describe('LinkedListNode', () => {
       const toStringCallback = (x: typeof nodeValue) =>
         `value: ${x.value}, key: ${x.key}`;
 
-      expect(list.toString(toStringCallback)).toBe('value: 1, key: test');
+      // Act
+      const received = list.toString(toStringCallback);
+
+      // Assert
+      expect(received).toBe('value: 1, key: test');
     });
   });
 });

src/doubly-linked-list/doubly-linked-list.ts

@@ -1,4 +1,6 @@
 import { LinkedListNode } from './linked-list-node';
+import { Comparator } from '../utils/comparator';
+import type { IComparator, CompareFunction } from '../utils/comparator';
 
 type NullableLinkedListNode<T = any> = LinkedListNode<T> | null;
 type FindMethodOptions<T = any> = {
@@ -12,29 +14,34 @@ export interface ILinkedList<T = any> {
   readonly length: number;
   readonly isEmpty: boolean;
 
+  append(value: T): this;
+  fromArray(array: T[]): this;
   toArray(): T[];
   toString(): string;
-  append(value: T): this;
   prepend(value: T): this;
-  reverse(): this;
   delete(value: T): NullableLinkedListNode<T>;
+  reverse(): this;
   insertAt(index: number, value: T): this;
   deleteHead(): NullableLinkedListNode<T>;
   deleteTail(): NullableLinkedListNode<T>;
   indexOf(value: T): number;
-  fromArray(array: T[]): this;
   find(options: FindMethodOptions<T>): NullableLinkedListNode<T>;
 }
 
 export class LinkedList<T = any> implements ILinkedList<T> {
-  #head: NullableLinkedListNode<T> = null;
+  #head: NullableLinkedListNode<T>;
 
-  #tail: NullableLinkedListNode<T> = null;
+  #tail: NullableLinkedListNode<T>;
 
-  #length: number = 0;
+  #length: number;
 
-  get isEmpty() {
-    return this.#head === null;
+  #compare: IComparator<T>;
+
+  constructor(compareFunction?: CompareFunction<T>) {
+    this.#head = null;
+    this.#tail = null;
+    this.#length = 0;
+    this.#compare = new Comparator(compareFunction);
   }
 
   get head() {
@@ -45,24 +52,12 @@ export class LinkedList<T = any> implements ILinkedList<T> {
     return this.#tail;
   }
 
-  get length(): number {
+  get length() {
     return this.#length;
   }
 
-  toArray() {
-    const array = [];
-    let currentNode = this.#head;
-
-    while (currentNode) {
-      array.push(currentNode.value);
-      currentNode = currentNode.next;
-    }
-
-    return array;
-  }
-
-  toString() {
-    return this.toArray().toString();
+  get isEmpty() {
+    return this.#head === null;
   }
 
   append(value: T) {
@@ -81,6 +76,30 @@ export class LinkedList<T = any> implements ILinkedList<T> {
     return this;
   }
 
+  fromArray(array: T[]) {
+    array.forEach((value) => {
+      this.append(value);
+    });
+
+    return this;
+  }
+
+  toArray() {
+    const array = [];
+    let currentNode = this.#head;
+
+    while (currentNode) {
+      array.push(currentNode.value);
+      currentNode = currentNode.next;
+    }
+
+    return array;
+  }
+
+  toString() {
+    return this.toArray().toString();
+  }
+
   prepend(value: T) {
     const newNode = new LinkedListNode(value);
 
@@ -102,29 +121,32 @@ export class LinkedList<T = any> implements ILinkedList<T> {
 
     let deletedNode = null as NullableLinkedListNode;
 
-    // Delete from the beginning of the list
-    if (value === this.#head.value) {
+    // Delete from the beginning of the list.
+    if (this.#compare.equal(value, this.#head.value)) {
       deletedNode = this.#head;
       this.#head = deletedNode.next;
 
-      // Update tail if the list becomes empty
+      // Update tail if the list becomes empty.
       if (this.#head === null) {
         this.#tail = null;
       }
     } else {
       let currentNode = this.#head;
 
-      // Search for the node by value
-      while (currentNode.next && value !== currentNode.next.value) {
+      // Search for the node by value.
+      while (
+        currentNode.next &&
+        !this.#compare.equal(value, currentNode.next.value)
+      ) {
         currentNode = currentNode.next;
       }
 
-      // Delete the node from the middle
+      // Delete the node from the middle.
       if (currentNode.next !== null) {
         deletedNode = currentNode.next;
         currentNode.next = deletedNode?.next;
 
-        // Update tail if the last node is deleted
+        // Update tail if the last node is deleted.
         if (currentNode.next === null) {
           this.#tail = currentNode;
         }
@@ -139,14 +161,17 @@ export class LinkedList<T = any> implements ILinkedList<T> {
   }
 
   reverse() {
-    if (this.#head === null || this.#head.next === null) return this;
+    if (this.#head === null || this.#head.next === null) {
+      return this;
+    }
 
     let currentNode = this.#head as NullableLinkedListNode;
     let prevNode = null;
 
-    while (currentNode) {
+    while (currentNode !== null) {
       const nextNode = currentNode.next;
-      [currentNode.next, prevNode] = [prevNode, currentNode];
+      currentNode.next = prevNode;
+      prevNode = currentNode;
 
       currentNode = nextNode;
     }
@@ -168,20 +193,22 @@ export class LinkedList<T = any> implements ILinkedList<T> {
   }
 
   insertAt(index: number, value: T): this {
-    if (index < 0 || index > this.#length) {
+    const isInvalidIndex = index < 0 || index > this.#length;
+
+    if (isInvalidIndex) {
       throw new Error(
         'Index should be greater than or equal to 0 and less than or equal to the list length.',
       );
     }
 
     if (index === 0) {
-      // Insert at the beginning
+      // Insert at the beginning.
       this.prepend(value);
     } else if (index === this.#length) {
-      // Insert end
+      // Insert at the end.
       this.append(value);
     } else {
-      // Insert in the middle
+      // Insert in the middle.
       const prevNode = this.#findNodeByIndex(index - 1);
       const newNode = new LinkedListNode(value);
 
@@ -199,8 +226,8 @@ export class LinkedList<T = any> implements ILinkedList<T> {
 
     const deletedNode = this.#head;
 
-    if (this.#head?.next) {
-      this.#head = this.#head.next;
+    if (deletedNode?.next) {
+      this.#head = deletedNode.next;
     } else {
       this.#head = null;
       this.#tail = null;
@@ -239,10 +266,10 @@ export class LinkedList<T = any> implements ILinkedList<T> {
 
   indexOf(value: T) {
     let count = 0;
-    let currentNode = this.head;
+    let currentNode = this.#head;
 
-    while (currentNode) {
-      if (value === currentNode.value) return count;
+    while (currentNode !== null) {
+      if (this.#compare.equal(value, currentNode.value)) return count;
 
       currentNode = currentNode.next;
       count += 1;
@@ -251,25 +278,17 @@ export class LinkedList<T = any> implements ILinkedList<T> {
     return -1;
   }
 
-  fromArray(array: T[]) {
-    array.forEach((value) => {
-      this.append(value);
-    });
-
-    return this;
-  }
-
   find({ value, predicate }: FindMethodOptions<T>) {
     if (this.#head === null) return null;
 
-    let currentNode = this.head as NullableLinkedListNode;
+    let currentNode = this.#head as NullableLinkedListNode;
 
     while (currentNode) {
       if (predicate && predicate(currentNode.value)) {
         return currentNode;
       }
 
-      if (value !== undefined && value === currentNode.value) {
+      if (value && this.#compare.equal(value, currentNode.value)) {
         return currentNode;
       }
 

src/linked-list/lined-list-node.spec.ts

@@ -7,7 +7,7 @@ describe('Comparator', () => {
     // Arrange
     const comparator = new Comparator<number>();
 
-    // Assert
+    // Act and Assert
     expect(comparator.lessThan(2, 5)).toBeTruthy();
     expect(comparator.greaterThan(5, 2)).toBeTruthy();
     expect(comparator.equal(2, 2)).toBeTruthy();

src/linked-list/linked-list.spec.ts

@@ -1,6 +1,8 @@
+import isEqual from 'lodash.isequal';
+
 export type CompareFunction<T> = (a: T, b: T) => -1 | 0 | 1;
 
-export interface ComparatorType<T> {
+export interface IComparator<T> {
   equal(a: T, b: T): boolean;
   lessThan(a: T, b: T): boolean;
   greaterThan(a: T, b: T): boolean;
@@ -9,21 +11,27 @@ export interface ComparatorType<T> {
   reverse(): void;
 }
 
-export class Comparator<T = any> implements ComparatorType<T> {
-  #compare: (a: any, b: any) => -1 | 0 | 1;
+export class Comparator<T = any> implements IComparator<T> {
+  #compare: CompareFunction<T>;
+
+  #isEqualFn: typeof isEqual;
 
   static defaultCompareFunction<T>(a: T, b: T) {
     if (a === b) return 0;
 
     return a < b ? -1 : 1;
   }
 
-  constructor(compareFunction?: CompareFunction<T>) {
+  constructor(
+    compareFunction?: CompareFunction<T>,
+    isEqualFn: typeof isEqual = isEqual,
+  ) {
     this.#compare = compareFunction || Comparator.defaultCompareFunction;
+    this.#isEqualFn = isEqualFn;
   }
 
   equal(a: T, b: T) {
-    return this.#compare(a, b) === 0;
+    return this.#isEqualFn(a, b);
   }
 
   lessThan(a: T, b: T) {

src/linked-list/linked-list.ts

@@ -1,4 +1,4 @@
 {
   "extends": "./tsconfig.json",
-  "include": ["src/**/*.ts"],
-}
+  "include": ["src/**/*.ts"]
+}

src/utils/comparator/comparator.spec.ts

@@ -19,5 +19,5 @@
       "bun-types" // add Bun global
     ]
   },
-  "include": ["src/**/*"],
+  "include": ["src/**/*"]
 }