Added linked list data structure with unit test cases

Author: linux-nerd

src/linked-list/linked-list.js

@@ -10,6 +10,9 @@ export class Node {
   get next() {
     return this._next;
   }
+  set next(node) {
+    this._next = node;
+  }
 }
 
 
@@ -22,6 +25,15 @@ export class LinkedList {
     this[_head] = null;
   }
 
+  *[Symbol.iterator]() {
+    let element = this.head;
+
+    while (element !== null) {
+      yield element.key;
+      element = element.next;
+    }
+  }
+
   get head() {
     return this[_head];
   }
@@ -34,10 +46,80 @@ export class LinkedList {
     return this.size() === 0;
   }
 
-  search(item) { }
-  insertLast(item) { }
-  insertFirst(item) { }
-  insertBefore(item, before) { }
-  insertAfter(item, after) { }
-  remove(item) { }
-}
+  search(item) {
+    return this._search(item).found;
+  }
+
+  insert(item) {
+    if(this.isEmpty()) {
+      this.insertFirst(item);
+    } else {
+      this.insertLast(item);
+    }
+    this[_size] += 1;
+  }
+
+  insertLast(item) {
+    let el = this[_head];
+    while(el && el.next !== null) {
+      el = el.next;
+    }
+
+    el.next = new Node(item);
+  }
+
+  insertFirst(item) {
+    this[_head] = new Node(item);
+  }
+
+  insertBefore(item, before) {
+    const {prev, curr, found} = this._search(before);
+
+    if(found) {
+      const node = new Node(item);
+      if(prev === null) {
+        this[_head] = node;
+      } else {
+        prev.next = node;
+      }
+      node.next = curr;
+      this[_size] += 1;
+    }
+  }
+  insertAfter(item, after) {
+    const {curr, next, found} = this._search(after);
+
+    if(found) {
+      curr.next = new Node(item);
+      curr.next.next = next;
+      this[_size] += 1;
+    }
+  }
+  remove(item) {
+    const {prev, next, found} = this._search(item);
+    if(found) {
+      if(prev === null) {
+        this[_head] = next;
+      } else {
+        prev.next = next;
+      }
+      this[_size] -= 1;
+    }
+  }
+
+  _search(item) {
+    let prev = null, curr = this.head, next = null, found = false;
+    while(curr !== null && !found) {
+      // TODO: Check for Object and Array as well
+      if(curr.key === item) {
+        next = curr.next;
+        found = true;
+        break;
+      }
+      prev = curr;
+      curr = curr.next;
+    }
+
+    return {prev, curr, next, found};
+  }
+}

src/linked-list/linked-list.spec.js

@@ -3,7 +3,7 @@ import { LinkedList } from './linked-list';
 describe('Linked List', () => {
   let list;
   beforeEach(() => {
-    list = new LinkedList
+    list = new LinkedList;
   });
 
   it('should create a linked list object', () => {
@@ -12,4 +12,99 @@ describe('Linked List', () => {
     expect(list.head).toBe(null);
     expect(list.isEmpty()).toBeTruthy();
   });
-});
+
+  it('should insert first item in the linked list', () => {
+    spyOn(list, 'insertFirst').and.callThrough();
+    list.insert('firstVal');
+
+    expect(list.insertFirst).toHaveBeenCalled();
+    expect(list.insertFirst).toHaveBeenCalledWith('firstVal');
+    expect(list.size()).toBe(1);
+    expect(list.isEmpty()).toBeFalsy();
+    expect(list.head.key).toContain('firstVal');
+    expect(list.head.next).toBe(null);
+  });
+
+  describe('When first item is inserted', () => {
+    beforeEach(() => {
+      list.insert('firstVal');
+    });
+
+    it('should insert items at the end', () => {
+      spyOn(list, 'insertLast').and.callThrough();
+      expect(list.size()).toBe(1);
+      list.insert('secondVal');
+
+      expect(list.insertLast).toHaveBeenCalled();
+      expect(list.insertLast).toHaveBeenCalledWith('secondVal');
+      expect(list.size()).toBe(2);
+      expect(list.head.next.key).toBe('secondVal');
+      expect(list.head.next.next).toBe(null);
+    });
+
+    it('should insert item after specified item', () => {
+      list.insertAfter('secondVal', 'firstVal');
+      expect(list.size()).toBe(2);
+      expect(list.search('secondVal')).toBeTruthy();
+
+      list.insertAfter('thirdVal', 'xyz');
+      expect(list.size()).toBe(2);
+      expect(list.search('thirdVal')).toBeFalsy();
+
+      list.insertAfter('thirdVal', 'firstVal');
+      expect(list.size()).toBe(3);
+      expect(list.search('thirdVal')).toBeTruthy();
+
+      expect([...list][1]).toContain('thirdVal');
+      expect([...list][2]).toContain('secondVal');
+    });
+
+    it('should insert item before specified item', () => {
+      list.insertBefore('secondVal', 'firstVal');
+      expect(list.size()).toBe(2);
+      expect(list.search('secondVal')).toBeTruthy();
+
+      list.insertBefore('thirdVal', 'firstVal');
+      expect(list.size()).toBe(3);
+      expect(list.search('thirdVal')).toBeTruthy();
+
+      list.insertBefore('forthVal', 'xyz');
+      expect(list.size()).toBe(3);
+      expect(list.search('forthVal')).toBeFalsy();
+    });
+  });
+
+  it('should search for item', () => {
+    expect(list.search('A')).toBeFalsy();
+
+    list.insert('A');
+    list.insert('B');
+    list.insert('C');
+
+    expect(list.search('B')).toBeTruthy();
+    expect(list.search('C')).toBeTruthy();
+    expect(list.search('D')).toBeFalsy();
+  });
+
+  it('should remove items from list', () => {
+    expect(list.size()).toBe(0);
+
+    list.insert('A');
+    list.insert('B');
+    list.insert('C');
+    expect(list.size()).toBe(3);
+
+    list.remove('B');
+    expect(list.size()).toBe(2);
+    expect(list.search('B')).toBeFalsy();
+
+    list.remove('A');
+    expect(list.size()).toBe(1);
+    expect(list.search('A')).toBeFalsy();
+
+    list.remove('C');
+    expect(list.size()).toBe(0);
+    expect(list.search('C')).toBeFalsy();
+  });
+
+});