Implement Stack with array, move unit-tests, create array helper

Author: NeurAlch

README.md

@@ -10,9 +10,9 @@ Most code in TypeScript is done mostly using TDD. Python is done mostly with Jup
 
 Examples:
 
-* [Algorithms](./src/tests/unit-tests/algos)
+* [Algorithms](src/tests/algos)
 * Data Structures
-  * [JS Array](./src/tests/unit-tests/data-structures/arrays.test.ts) [(big-o)](./src/tests/unit-tests/data-structures/array.big-o.test.ts)
+  * [JS Array](src/tests/data-structures/arrays.test.ts) [(big-o)](src/tests/data-structures/array.big-o.test.ts)
     * Sort
       * Without a sort function it will convert elements into strings, 80 comes before 9
       * The sorting algorithm is stable
@@ -24,14 +24,16 @@ Examples:
           *  === 0	keep original order of a and b
         * `const compare = (a, b) => a > b ? -1 : 0;`
           * Will have different results in V8 and SpiderMonkey
-  * [JS Map](./src/tests/unit-tests/data-structures/map.test.ts)
-  * [JS Set](./src/tests/unit-tests/data-structures/set.test.ts)
-  * [Singly Linked List](./src/tests/unit-tests/data-structures/singly-linked-list.test.ts)
+  * [JS Map](src/tests/data-structures/map.test.ts)
+  * [JS Set](src/tests/data-structures/set.test.ts)
+  * [Stack using Array](src/tests/data-structures/stack.test.ts)
+  * [Stack using Linked List](src/tests/data-structures/stack-with-ll.test.ts)
+  * [Singly Linked List](src/tests/data-structures/singly-linked-list.test.ts)
     * Benefits of a sorted list are lost on a sorted SLL
-  * [Double Linked List](./src/tests/unit-tests/data-structures/double-linked-list.test.ts)
+  * [Double Linked List](src/tests/data-structures/double-linked-list.test.ts)
     * Each node can be anywhere in memory, no need to resize an array
     * We don't need to shift position of elements when inserting or deleting like in an array
-  * [Queue using Double Linked List](./src/tests/unit-tests/data-structures/queue-with-dll.test.ts)
+  * [Queue using Double Linked List](src/tests/data-structures/queue-with-dll.test.ts)
     * Using a DLL allows us to do operations O(1) for enqueue and dequeue
       * Faster than using a JS Array or an SLL
 * Design Patterns

src/data-structures/sized-stack.ts

@@ -1,31 +1,60 @@
+import { createArrayOfSize } from '../helpers/array';
+
 export interface IStack<TValue> {
   length: number;
 
+  isFull(): boolean;
+  isEmpty(): boolean;
   insert(value: TValue): void;
   delete(): TValue | undefined;
   read(): TValue | undefined;
 }
 
 export class Stack<TValue> implements IStack<TValue> {
-  protected _array: TValue[];
-
-  constructor() {
-    this._array = [];
-  }
+  protected _array: Array<TValue | undefined>;
+  protected _maxSize: number;
+  protected _topPointer: number;
 
-  insert(value: TValue): void {
-    this._array.push(value);
+  constructor(maxSize: number) {
+    this._topPointer = -1;
+    this._maxSize = maxSize;
+    this._array = createArrayOfSize<TValue | undefined>(maxSize, undefined);
   }
 
   delete(): TValue | undefined {
-    return this._array.pop();
+    if (this.isEmpty()) {
+      throw new Error('Stack is empty');
+    }
+    const value = this._array[this._topPointer];
+    this._array[this._topPointer] = undefined;
+    this._topPointer--;
+    return value;
   }
 
   read(): TValue | undefined {
-    return this._array[this._array.length - 1];
+    if (this.isEmpty()) {
+      return undefined;
+    }
+    return this._array[this._topPointer];
   }
 
   get length(): number {
-    return this._array.length;
+    return this._topPointer + 1;
+  }
+
+  insert(value: TValue): void {
+    if (this.isFull()) {
+      throw new Error('Stack is full');
+    }
+    this._topPointer++;
+    this._array[this._topPointer] = value;
+  }
+
+  isEmpty(): boolean {
+    return this._topPointer === -1;
+  }
+
+  isFull(): boolean {
+    return this._topPointer + 1 === this._maxSize;
   }
 }

src/data-structures/stack-with-ll.ts

@@ -0,0 +1,8 @@
+export const createArrayOfSize = <T>(size: number, defaultValue: T): T[] => {
+  let i = 0;
+  const array: T[] = Array(size);
+  while (i < size) {
+    array[i++] = defaultValue;
+  }
+  return array;
+};

src/data-structures/stack.ts

@@ -1,4 +1,4 @@
-import { binarySearch } from '../../../algos/binarySearch';
+import { binarySearch } from '../../algos/binarySearch';
 
 describe('binarySearch', () => {
   it('finds the value', () => {

src/helpers/array.ts

@@ -1,4 +1,4 @@
-import { FIBONACCI_CACHE, fibonacciIterative, fibonacciRecursive, fibonacciRecursiveMemoized } from '../../../algos/fibonacci';
+import { FIBONACCI_CACHE, fibonacciIterative, fibonacciRecursive, fibonacciRecursiveMemoized } from '../../algos/fibonacci';
 
 export const EXPECTED_FIBONACCI_SEQ = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144];
 

src/tests/unit-tests/algos/binarySearch.test.ts src/tests/algos/binarySearch.test.ts

@@ -1,4 +1,4 @@
-import { insertSorted } from '../../../algos/insertSorted';
+import { insertSorted } from '../../algos/insertSorted';
 
 describe('insertSorted', () => {
   it('should insert a number at the right spot on a sorted array', () => {

src/tests/unit-tests/algos/fibonacci.test.ts src/tests/algos/fibonacci.test.ts

@@ -1,4 +1,4 @@
-import { largestValueCompare, largestValueLoop, largestValueBuiltin } from '../../../algos/largest-Value';
+import { largestValueCompare, largestValueLoop, largestValueBuiltin } from '../../algos/largest-Value';
 
 const ONE_VALUE = [1];
 const ZERO_VALUE = [0];

src/tests/unit-tests/algos/insertSorted.test.ts src/tests/algos/insertSorted.test.ts

@@ -1,4 +1,4 @@
-import { maxIndex } from '../../../algos/maxIndex';
+import { maxIndex } from '../../algos/maxIndex';
 
 describe('max', () => {
   it('should return -1 if empty', () => {

src/tests/unit-tests/algos/largest-value.test.ts src/tests/algos/largest-value.test.ts

@@ -1,5 +1,5 @@
-import { DoubleLinkedList } from '../../../data-structures/double-linked-list';
-import { reverseDoubleLinkedList } from '../../../algos/reverse-double-linked-list';
+import { DoubleLinkedList } from '../../data-structures/double-linked-list';
+import { reverseDoubleLinkedList } from '../../algos/reverse-double-linked-list';
 
 describe('reverse double linked list', () => {
   it('reverses a double linked list iteratively', () => {

src/tests/unit-tests/algos/maxIndex.test.ts src/tests/algos/maxIndex.test.ts

@@ -1,5 +1,5 @@
-import { SinglyLinkedList } from '../../../data-structures/singly-linked-list';
-import { reverseLinkedList, reverseLinkedListRecursive } from '../../../algos/reverse-linked-list';
+import { SinglyLinkedList } from '../../data-structures/singly-linked-list';
+import { reverseLinkedList, reverseLinkedListRecursive } from '../../algos/reverse-linked-list';
 
 describe('reverse linked list', () => {
   it('reverses a linked list iteratively', () => {

src/tests/unit-tests/algos/reverse-double-linked-list.test.ts src/tests/algos/reverse-double-linked-list.test.ts

@@ -1,4 +1,4 @@
-import { seqSearch } from '../../../algos/seqSearch';
+import { seqSearch } from '../../algos/seqSearch';
 
 describe('seqSearch', () => {
   it('returns -1 if target is not found', () => {

src/tests/unit-tests/algos/reverse-linked-list.test.ts src/tests/algos/reverse-linked-list.test.ts

@@ -1,4 +1,4 @@
-import { CSR, sparseMatrixFromCSR, sparseMatrixToCSR } from '../../../algos/sparseMatrix';
+import { CSR, sparseMatrixFromCSR, sparseMatrixToCSR } from '../../algos/sparseMatrix';
 
 interface Sample {
   to: CSR;

src/tests/unit-tests/algos/seqSearch.test.ts src/tests/algos/seqSearch.test.ts

@@ -1,4 +1,4 @@
-import { twoNumberSumLoops, twoNumberSumPointers, twoNumberSumHash } from '../../../algos/twoNumberSum';
+import { twoNumberSumLoops, twoNumberSumPointers, twoNumberSumHash } from '../../algos/twoNumberSum';
 
 describe('twoNumberSum', () => {
   it('returns the correct values', () => {

src/tests/unit-tests/algos/sparseMatrix.test.ts src/tests/algos/sparseMatrix.test.ts

@@ -1,4 +1,4 @@
-import { binarySearch } from '../../../algos/binarySearch';
+import { binarySearch } from '../../algos/binarySearch';
 
 describe('array Big-O time', () => {
   it('returns value at O(1)', () => {

src/tests/unit-tests/algos/twoNumberSum.test.ts src/tests/algos/twoNumberSum.test.ts

@@ -1,4 +1,4 @@
-import { Deque } from '../../../data-structures/deque';
+import { Deque } from '../../data-structures/deque';
 
 describe('Deque', () => {
   it('should create an instance', () => {

src/tests/unit-tests/data-structures/array.big-o.test.ts src/tests/data-structures/array.big-o.test.ts

@@ -1,4 +1,4 @@
-import { DoubleLinkedList } from '../../../data-structures/double-linked-list';
+import { DoubleLinkedList } from '../../data-structures/double-linked-list';
 
 describe('DoubleLinkedList', () => {
   it('should create an instance', () => {

src/tests/unit-tests/data-structures/arrays.test.ts src/tests/data-structures/arrays.test.ts

@@ -1,4 +1,4 @@
-import { QueueWithDoubleLinkedList } from '../../../data-structures/queue-with-dll';
+import { QueueWithDoubleLinkedList } from '../../data-structures/queue-with-dll';
 
 type TaskType = 'wake-up' | 'breakfast' | 'work' | 'lunch' | 'dinner' | 'sleep';
 

src/tests/unit-tests/data-structures/deque.test.ts src/tests/data-structures/deque.test.ts

@@ -1,4 +1,4 @@
-import { Queue } from '../../../data-structures/queue';
+import { Queue } from '../../data-structures/queue';
 
 describe('Queue', () => {
   it('should create an instance', () => {

src/tests/unit-tests/data-structures/double-linked-list.test.ts src/tests/data-structures/double-linked-list.test.ts

@@ -1,4 +1,4 @@
-import { SinglyLinkedList } from '../../../data-structures/singly-linked-list';
+import { SinglyLinkedList } from '../../data-structures/singly-linked-list';
 
 describe('SinglyLinkedList', () => {
   it('should create an instance', () => {

src/tests/unit-tests/data-structures/map.test.ts src/tests/data-structures/map.test.ts

@@ -0,0 +1,60 @@
+import { Stack } from '../../data-structures/stack';
+
+describe('Stack', () => {
+  it('should create an instance', () => {
+    const stack = new Stack(10);
+    expect(stack).toBeInstanceOf(Stack);
+    expect(stack.length).toBe(0);
+    expect(stack.read()).toBeUndefined();
+  });
+
+  it('should push and pop values', () => {
+    const stack = new Stack(10);
+    stack.insert(1);
+    expect(stack.length).toBe(1);
+    expect(stack.delete()).toBe(1);
+    expect(stack.length).toBe(0);
+    stack.insert(1);
+    stack.insert(2);
+    expect(stack.read()).toBe(2);
+    expect(stack.length).toBe(2);
+
+    expect(stack.delete()).toBe(2);
+    expect(stack.read()).toBe(1);
+    expect(stack.length).toBe(1);
+    expect(stack.delete()).toBe(1);
+    expect(stack.length).toBe(0);
+    expect(stack.read()).toBe(undefined);
+  });
+
+  it('should throw error for overflow or underflow', () => {
+    const stack = new Stack(3);
+    expect(stack.isFull()).toBe(false);
+    stack.insert(1);
+    stack.insert(2);
+    stack.insert(3);
+    expect(stack.isFull()).toBe(true);
+    expect(() => {
+      stack.insert(4);
+    }).toThrowError('Stack is full');
+    expect(stack.length).toBe(3);
+    expect(stack.read()).toBe(3);
+    expect(stack.delete()).toBe(3);
+    stack.insert(3);
+    expect(() => {
+      stack.insert(4);
+    }).toThrowError('Stack is full');
+    expect(stack.length).toBe(3);
+    expect(stack.read()).toBe(3);
+    expect(stack.isEmpty()).toBe(false);
+    stack.delete();
+    stack.delete();
+    stack.delete();
+    expect(stack.isEmpty()).toBe(true);
+    expect(() => {
+      stack.delete();
+    }).toThrowError('Stack is empty');
+    expect(stack.length).toBe(0);
+    expect(stack.read()).toBeUndefined();
+  });
+});

src/tests/unit-tests/data-structures/queue-with-dll.test.ts src/tests/data-structures/queue-with-dll.test.ts

@@ -0,0 +1,17 @@
+import { createArrayOfSize } from '../../helpers/array';
+
+describe('array helpers', () => {
+  it('createArrayOfSize', () => {
+    const array = createArrayOfSize<number>(10, 0);
+    expect(array.length).toBe(10);
+    expect(array[0]).toBe(0);
+    expect(array[9]).toBe(0);
+    expect(array).toEqual([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+    const array2 = createArrayOfSize<number | undefined>(10, undefined);
+    expect(array2.length).toBe(10);
+    expect(array2[0]).toBe(undefined);
+    expect(array2[9]).toBe(undefined);
+    expect(array2).toEqual([undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined]);
+  });
+});

src/tests/unit-tests/data-structures/queue.test.ts src/tests/data-structures/queue.test.ts

@@ -1,7 +1,7 @@
 module.exports = function () {
   return {
-    files: ['src/**/*.ts', '!src/tests/**/*.test.ts', 'src/data/*.txt'],
-    tests: ['src/tests/unit-tests/**/*.test.ts'],
+    files: ['src/**/*.ts', '!src/tests/**/*.test.ts'],
+    tests: ['src/tests/**/*.test.ts'],
     env: {
       type: 'node',
     },