chapter 05: [LinkedLists]

Author: loiane

README.md

@@ -19,6 +19,9 @@ Work in Progress.
 ### Third Edition Updates
 
 * Algorithms using ES2015+
+* All chapters reviewed and rewritten
+* New data structures and algorithms
+* Three (3) new chapters
 * Creation of a Data Structures and Algorithms library that can be used in the browser or with Node.js
 * Algorithms tested with Mocha + Chai (test code available in `test` directory)
 * TypeScript version of the source code included

examples/PacktDataStructuresAlgorithms.min.js

@@ -0,0 +1,35 @@
+import DoublyLinkedList from './doubly-linked-list';
+
+export default class StackLinkedList {
+  constructor() {
+    this.items = new DoublyLinkedList();
+  }
+  push(element) {
+    this.items.push(element);
+  }
+  pop() {
+    if (this.isEmpty()) {
+      return undefined;
+    }
+    const result = this.items.removeAt(this.size() - 1);
+    return result;
+  }
+  peek() {
+    if (this.isEmpty()) {
+      return undefined;
+    }
+    return this.items.getElementAt(this.size() - 1).element;
+  }
+  isEmpty() {
+    return this.items.isEmpty();
+  }
+  size() {
+    return this.items.size();
+  }
+  clear() {
+    this.items.clear();
+  }
+  toString() {
+    return this.items.toString();
+  }
+}

src/js/data-structures/stack-linked-list.js

@@ -10,10 +10,11 @@ import { parenthesesChecker } from './others/balanced-symbols';
 
 import * as _util from './util';
 
-export { default as CircularLinkedList } from './data-structures/circular-linked-list';
-export { default as DoublyLinkedList } from './data-structures/doubly-linked-list';
 export { default as LinkedList } from './data-structures/linked-list';
+export { default as DoublyLinkedList } from './data-structures/doubly-linked-list';
+export { default as CircularLinkedList } from './data-structures/circular-linked-list';
 export { default as SortedLinkedList } from './data-structures/sorted-linked-list';
+export { default as StackLinkedList } from './data-structures/stack-linked-list';
 
 export const util = _util;
 

src/js/index.js

@@ -42,7 +42,6 @@ export default class DoublyLinkedList<T> extends LinkedList<T> {
         }
       } else if (index === this.count) {
         // last item // NEW
-
         current = this.tail; // {2}
         current.next = node;
         node.prev = current;

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

@@ -0,0 +1,44 @@
+import DoublyLinkedList from './doubly-linked-list';
+
+export default class StackLinkedList<T> {
+  private items: DoublyLinkedList<T>;
+
+  constructor() {
+    this.items = new DoublyLinkedList<T>();
+  }
+
+  push(element: T) {
+    this.items.push(element);
+  }
+
+  pop() {
+    if (this.isEmpty()) {
+      return undefined;
+    }
+    const result = this.items.removeAt(this.size() - 1);
+    return result;
+  }
+
+  peek() {
+    if (this.isEmpty()) {
+      return undefined;
+    }
+    return this.items.getElementAt(this.size() - 1).element;
+  }
+
+  isEmpty() {
+    return this.items.isEmpty();
+  }
+
+  size() {
+    return this.items.size();
+  }
+
+  clear() {
+    this.items.clear();
+  }
+
+  toString() {
+    return this.items.toString();
+  }
+}

src/ts/data-structures/stack-linked-list.ts

@@ -1,12 +1,14 @@
 import * as _util from './util';
 
-export { default as CircularLinkedList } from './data-structures/circular-linked-list';
-export { default as DoublyLinkedList } from './data-structures/doubly-linked-list';
 export { default as LinkedList } from './data-structures/linked-list';
+export { default as DoublyLinkedList } from './data-structures/doubly-linked-list';
+export { default as CircularLinkedList } from './data-structures/circular-linked-list';
 export { default as SortedLinkedList } from './data-structures/sorted-linked-list';
+export { default as StackLinkedList } from './data-structures/stack-linked-list';
 
 export const util = _util;
 
+
 /* import { hotPotato } from './others/hot-potato';
 import { palindromeChecker } from './others/palindrome-checker';
 import Deque from './data-structures/deque';

src/ts/index.ts

@@ -0,0 +1,157 @@
+import 'mocha';
+import { expect } from 'chai';
+import { StackLinkedList } from '../../../src/js/index';
+import MyObj from './my-obj';
+
+describe('StackLinkedList', () => {
+  let stack;
+
+  beforeEach(() => {
+    stack = new StackLinkedList();
+  });
+
+  it('starts empty', () => {
+    expect(stack.size()).to.equal(0);
+    expect(stack.isEmpty()).to.equal(true);
+  });
+
+  it('pushes elements', () => {
+    stack.push(1);
+    expect(stack.size()).to.equal(1);
+    stack.push(2);
+    expect(stack.size()).to.equal(2);
+    stack.push(3);
+    expect(stack.size()).to.equal(3);
+
+    expect(stack.isEmpty()).to.equal(false);
+  });
+
+  it('pops elements', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+
+    expect(stack.pop()).to.equal(3);
+    expect(stack.pop()).to.equal(2);
+    expect(stack.pop()).to.equal(1);
+    expect(stack.pop()).to.equal(undefined);
+  });
+
+  it('implements LIFO logic', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+
+    expect(stack.pop()).to.equal(3);
+    expect(stack.pop()).to.equal(2);
+    expect(stack.pop()).to.equal(1);
+    expect(stack.pop()).to.equal(undefined);
+  });
+
+  it('allows to peek at the top element in he stack without popping it', () => {
+    expect(stack.peek()).to.equal(undefined);
+
+    stack.push(1);
+    expect(stack.peek()).to.equal(1);
+
+    stack.push(2);
+    expect(stack.peek()).to.equal(2);
+
+    stack.pop();
+    expect(stack.peek()).to.equal(1);
+  });
+
+  it('returns the correct size', () => {
+    expect(stack.size()).to.equal(0);
+    stack.push(1);
+    expect(stack.size()).to.equal(1);
+    stack.push(2);
+    expect(stack.size()).to.equal(2);
+    stack.push(3);
+    expect(stack.size()).to.equal(3);
+
+    stack.clear();
+    expect(stack.isEmpty()).to.equal(true);
+
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+
+    stack.pop();
+    expect(stack.size()).to.equal(2);
+    stack.pop();
+    expect(stack.size()).to.equal(1);
+    stack.pop();
+    expect(stack.size()).to.equal(0);
+    stack.pop();
+    expect(stack.size()).to.equal(0);
+  });
+
+  it('returns if it is empty', () => {
+    expect(stack.isEmpty()).to.equal(true);
+    stack.push(1);
+    expect(stack.isEmpty()).to.equal(false);
+    stack.push(2);
+    expect(stack.isEmpty()).to.equal(false);
+    stack.push(3);
+    expect(stack.isEmpty()).to.equal(false);
+
+    stack.clear();
+    expect(stack.isEmpty()).to.equal(true);
+
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+
+    stack.pop();
+    expect(stack.isEmpty()).to.equal(false);
+    stack.pop();
+    expect(stack.isEmpty()).to.equal(false);
+    stack.pop();
+    expect(stack.isEmpty()).to.equal(true);
+    stack.pop();
+    expect(stack.isEmpty()).to.equal(true);
+  });
+
+  it('clears the stack', () => {
+    stack.clear();
+    expect(stack.isEmpty()).to.equal(true);
+
+    stack.push(1);
+    stack.push(2);
+
+    stack.clear();
+    expect(stack.isEmpty()).to.equal(true);
+  });
+
+  it('returns toString primitive types', () => {
+    expect(stack.toString()).to.equal('');
+
+    stack.push(1);
+    expect(stack.toString()).to.equal('1');
+
+    stack.push(2);
+    expect(stack.toString()).to.equal('1,2');
+
+    stack.clear();
+    expect(stack.toString()).to.equal('');
+
+    const stackString = new StackLinkedList();
+    stackString.push('el1');
+    expect(stackString.toString()).to.equal('el1');
+
+    stackString.push('el2');
+    expect(stackString.toString()).to.equal('el1,el2');
+  });
+
+  it('returns toString objects', () => {
+    const stackMyObj = new StackLinkedList();
+    expect(stackMyObj.toString()).to.equal('');
+
+    stackMyObj.push(new MyObj(1, 2));
+    expect(stackMyObj.toString()).to.equal('1|2');
+
+    stackMyObj.push(new MyObj(3, 4));
+    expect(stackMyObj.toString()).to.equal('1|2,3|4');
+  });
+});