Merge pull request #35 from linux-nerd/feature/#20_singly_linked_list

#20 singly linked list

Author: linux-nerd

README.md

@@ -45,6 +45,7 @@ Data structures covered so far -
 - [Binary Search Tree](#binary-search-tree)
 - [Graph](#graph)
 - [Queue](#queue)
+- [Linked List](#link-list)
 
 # Contribution
 Your contribution is highly appreciated. You can contribute in several ways -
@@ -196,3 +197,48 @@ Clear the entire queue at once
 ```js
 queue.clear() // this will empty the queue
 ```
+
+# <a name="link-list"></a> Linked List
+
+Import LinkedList data structure and create a list object.
+
+```js
+import { LinkedList } from 'es6-data-structures/lib/ds';
+const list = new LinkedList;
+```
+
+Insert and Remove Items from the list
+
+```js
+// inserts item at the end of the list
+list.insert('firstVal');
+list.insert('SecondVal');
+
+list.insertAfter('Mid', 'firstVal');  // insert Mid after firstVal
+list.insertBefore('xyz', 'secondVal'); // insert xyz before secondVal
+
+list.remove('firstVal') // removes firstVal from the list.
+```
+
+Get size and search for an item and check if the list is empty
+
+```js
+list.size() // 3
+list.search('xyz') // true
+list.search('abc') // false
+list.isEmpty() // false
+```
+
+Iterate over list using for...of loop
+
+```js
+for(const item of list) {
+  console.log(item) // 'firstVal', 'Mid', 'xyz', 'secondVal'
+}
+```
+
+Usage as spread operator
+
+```js
+const items = [...list] // ['firstVal', 'Mid', 'xyz', 'secondVal']
+```

src/linked-list/linked-list.js

@@ -0,0 +1,125 @@
+export class Node {
+  constructor(key, next = null) {
+    this._key = key;
+    this._next = next;
+  }
+
+  get key() {
+    return this._key
+  }
+  get next() {
+    return this._next;
+  }
+  set next(node) {
+    this._next = node;
+  }
+}
+
+
+const _size = Symbol('size');
+const _head = Symbol('head');
+
+export class LinkedList {
+  constructor() {
+    this[_size] = 0;
+    this[_head] = null;
+  }
+
+  *[Symbol.iterator]() {
+    let element = this.head;
+
+    while (element !== null) {
+      yield element.key;
+      element = element.next;
+    }
+  }
+
+  get head() {
+    return this[_head];
+  }
+
+  size() {
+    return this[_size];
+  }
+
+  isEmpty() {
+    return this.size() === 0;
+  }
+
+  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

@@ -0,0 +1,110 @@
+import { LinkedList } from './linked-list';
+
+describe('Linked List', () => {
+  let list;
+  beforeEach(() => {
+    list = new LinkedList;
+  });
+
+  it('should create a linked list object', () => {
+    expect(list).toBeDefined();
+    expect(list.size()).toBe(0);
+    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();
+  });
+
+});

src/test-index.js

@@ -1,4 +1,5 @@
 require('./binary-search-tree/binary-search-tree.spec');
 require('./graph/graph.spec');
-require('./queue/queue.spec');
 require('./graph/adj-list.spec');
+require('./queue/queue.spec');
+require('./linked-list/linked-list.spec');

typings/data-structures.d.ts

@@ -34,8 +34,14 @@ declare namespace DataStructures {
     enqueue(o): void;
     dequeue(): Error | void;
     size(): number;
-    isEmpty(): void;
+    isEmpty(): boolean;
     top(): any;
     clear(): void;
   }
+
+  class LinkedList {
+    head(): any;
+    size(): number;
+    isEmpty(): boolean;
+  }
 }