feat: implement doubly linked list class

Author: francislagares

src/doubly-linked-list/DoublyLinkedList.ts

@@ -0,0 +1,110 @@
+import { DoublyNodeList, INode } from './DoublyNodeList';
+
+export class DoublyLinkedList<T> {
+  public head: INode<T> | null;
+  public tail: INode<T> | null;
+  protected length: number;
+
+  constructor(data?: T) {
+    this.head = new DoublyNodeList(data);
+    this.tail = this.head;
+    this.length = 1;
+  }
+
+  public append(data: T): DoublyLinkedList<T> {
+    // Create a new node
+    const newNode = new DoublyNodeList(data);
+    // Add prev property at the end of the list
+    newNode.prev = this.tail;
+    // Attach it after the first node
+    this.tail.next = newNode;
+    // Update the tail to point the newNode
+    this.tail = newNode;
+    // Increment length
+    this.length++;
+    // Return the new created list
+    return this;
+  }
+
+  public prepend(data: T): DoublyLinkedList<T> {
+    // Create a new node
+    const newNode = new DoublyNodeList(data);
+    //Check if there is no head to make a new node
+    if (!this.head) {
+      this.head = newNode;
+      this.tail = newNode;
+
+      return this;
+    }
+    // Create a pointer to the head of the list
+    newNode.next = this.head;
+    // Point prev to new node because it's no longer the head
+    this.head.prev = newNode;
+    // Update head reference to the newNode
+    this.head = newNode;
+    // Increment length
+    this.length++;
+    // Return the new created list
+    return this;
+  }
+
+  // Prints linked list in array format for better readability
+  public printList(): Array<T> {
+    const array: T[] = [];
+    let currentNode = this.head;
+    while (currentNode !== null) {
+      array.push(currentNode.data);
+      currentNode = currentNode.next;
+    }
+    return array;
+  }
+
+  public insert(index: number, data: T) {
+    // Check params
+    if (index >= this.length) {
+      return this.append(data);
+    }
+    // Create a new node
+    const newNode = new DoublyNodeList(data);
+    // Get the index of previous node
+    const prevNode = this.traverse(index - 1);
+    // Temporarily hold the pointer to previous node
+    const nextNode = prevNode.next;
+    // Point previous node to the new one
+    prevNode.next = newNode;
+    // Point new node to previous
+    newNode.prev = prevNode;
+    // Point new node to next one
+    newNode.next = nextNode;
+    // Point back nextNode with the new one
+    nextNode.prev = newNode;
+    // Increment length
+    this.length++;
+    // Print list to the console
+    return this.printList();
+  }
+
+  public remove(index: number) {
+    // Get the index of previous node
+    const prevNode = this.traverse(index - 1);
+    // Reference node to be removed
+    const currentNode = prevNode.next;
+    // Reference previous node with the next after the removed one
+    prevNode.next = currentNode.next;
+    // Decrease length
+    this.length--;
+    // Print list to the console
+    return this.printList();
+  }
+
+  private traverse(index: number): INode<T> {
+    // Check params
+    let counter = 0;
+    let currentNode = this.head;
+    while (counter !== index) {
+      currentNode = currentNode.next;
+      counter++;
+    }
+    return currentNode;
+  }
+}

src/doubly-linked-list/DoublyNodeList.ts

@@ -0,0 +1,17 @@
+export interface INode<T> {
+  data: T;
+  next?: INode<T>;
+  prev?: INode<T>;
+}
+
+export class DoublyNodeList<T> implements INode<T> {
+  public data: T;
+  public next?: INode<T>;
+  public prev?: INode<T>;
+
+  constructor(data?: T) {
+    this.data = data;
+    this.next = null;
+    this.prev = null;
+  }
+}

src/doubly-linked-list/__tests__/DoublyLinkedList.test.ts

@@ -0,0 +1,66 @@
+import { DoublyLinkedList } from '../DoublyLinkedList';
+
+describe('Doubly Linked List', () => {
+  test('create empty linked list', () => {
+    const doublyLinkedList = new DoublyLinkedList<string>();
+
+    expect(doublyLinkedList.head).toEqual({
+      data: undefined,
+      next: null,
+      prev: null,
+    });
+  });
+
+  test('append node to linked list', () => {
+    const doublyLinkedList = new DoublyLinkedList<number>(10);
+
+    doublyLinkedList.append(15);
+    doublyLinkedList.append(20);
+
+    expect(doublyLinkedList.head.prev).toBeNull();
+    expect(doublyLinkedList.head.data).toBe(10);
+    expect(doublyLinkedList.head.next.data).toBe(15);
+    expect(doublyLinkedList.tail.data).toBe(20);
+    expect(doublyLinkedList.tail.prev.data).toBe(15);
+    expect(doublyLinkedList.tail.next).toBeNull();
+  });
+
+  test('prepend node to linked list', () => {
+    const doublyLinkedList = new DoublyLinkedList<number>();
+
+    doublyLinkedList.prepend(10);
+
+    expect(doublyLinkedList.head.data).toBe(10);
+    expect(doublyLinkedList.tail.prev.data).toBe(10);
+
+    doublyLinkedList.append(15);
+    doublyLinkedList.append(20);
+  });
+
+  test('insert node list in a given index', () => {
+    const doublyLinkedList = new DoublyLinkedList<object>();
+
+    const nodeValue1 = { value: 1, key: 'key1' };
+    const nodeValue2 = { value: 2, key: 'key2' };
+    const nodeValue3 = { value: 3, key: 'key3' };
+
+    doublyLinkedList
+      .append(nodeValue3)
+      .prepend(nodeValue1)
+      .insert(1, nodeValue2);
+
+    expect(doublyLinkedList.head.data).toEqual({ value: 1, key: 'key1' });
+    expect(doublyLinkedList.head.next.data).toEqual({ value: 2, key: 'key2' });
+    expect(doublyLinkedList.tail.data).toEqual({ value: 3, key: 'key3' });
+  });
+
+  test('print list in array format', () => {
+    const doublyLinkedList = new DoublyLinkedList<number>(10);
+
+    doublyLinkedList.append(15);
+    doublyLinkedList.append(20);
+    doublyLinkedList.append(25);
+
+    expect(doublyLinkedList.printList()).toEqual([10, 15, 20, 25]);
+  });
+});

src/doubly-linked-list/__tests__/DoublyNodeList.test.ts

@@ -0,0 +1,21 @@
+import { DoublyNodeList } from '../DoublyNodeList';
+
+describe('Doubly Linked List Node', () => {
+  test('create empty node list', () => {
+    const node = new DoublyNodeList<null>();
+
+    expect(node.data).toBeUndefined();
+    expect(node.next).toBeNull();
+    expect(node.next).toBeNull();
+  });
+
+  test('create list node with object as a value', () => {
+    const nodeValue = { key: 'test', value: 1 };
+    const node = new DoublyNodeList(nodeValue);
+
+    expect(node.data.key).toBe('test');
+    expect(node.data.value).toBe(1);
+    expect(node.next).toBeNull();
+    expect(node.prev).toBeNull();
+  });
+});