feat: implement stack class with linked list

Author: francislagares

src/index.ts

@@ -2,3 +2,5 @@ console.log('Typescript Data Structures & Algorithms');
 import './arrays/arrayClass';
 import './hash-table/HashTable';
 import './linked-list/LinkedList';
+import './doubly-linked-list/DoublyLinkedList';
+import './stack/StackClass';

src/stack/StackClass.ts

@@ -0,0 +1,48 @@
+import { StackNode } from './StackNode';
+
+export interface Stack<T> {
+  size: number;
+  top: StackNode<T> | null;
+  bottom: StackNode<T> | null;
+  push(value: T): number;
+  pop(): StackNode<T> | null;
+  peek(): StackNode<T> | null;
+}
+
+export class Stack<T> implements Stack<T> {
+  public constructor() {
+    this.size = 0;
+    this.top = null;
+    this.bottom = null;
+  }
+
+  public peek(): StackNode<T> | null {
+    return this.top;
+  }
+
+  public push(value: T) {
+    const node = new StackNode(value);
+    if (this.size === 0) {
+      this.top = node;
+      this.bottom = node;
+    } else {
+      const currentTop = this.top;
+      this.top = node;
+      this.top.next = currentTop;
+    }
+
+    this.size += 1;
+    return this.size;
+  }
+
+  public pop(): StackNode<T> | null {
+    if (this.size > 0) {
+      const nodeToBeRemoved = this.top;
+      this.top = nodeToBeRemoved.next;
+      this.size -= 1;
+      nodeToBeRemoved.next = null;
+      return nodeToBeRemoved;
+    }
+    return null;
+  }
+}

src/stack/StackNode.ts

@@ -0,0 +1,11 @@
+export interface StackNode<T> {
+  data: T | null;
+  next: StackNode<T> | null;
+}
+
+export class StackNode<T> implements StackNode<T> {
+  constructor(data?: T) {
+    this.data = data;
+    this.next = null;
+  }
+}

src/stack/__tests__/StackClass.test.ts

@@ -0,0 +1,44 @@
+import { Stack } from '../StackClass';
+
+describe('Stack', () => {
+  test('create an empty stack', () => {
+    const stack = new Stack();
+
+    expect(stack).not.toBeNull();
+  });
+
+  test('push data to stack', () => {
+    const stack = new Stack();
+
+    stack.push({ value: 'test1', key: 'key1' });
+    stack.push({ value: 'test2', key: 'key2' });
+
+    expect(stack.top.data['value']).toBe('test2');
+    expect(stack.top.next.data['value']).toBe('test1');
+    expect(stack.bottom.data['value']).toBe('test1');
+    expect(stack.bottom.next).toBeNull();
+  });
+
+  test('remove data from stack', () => {
+    const stack = new Stack<number>();
+
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+
+    expect(stack.pop().data).toBe(3);
+    expect(stack.pop().data).toBe(2);
+    expect(stack.pop().data).toBe(1);
+    expect(stack.pop()).toBeNull();
+  });
+
+  test('peek node from stack', () => {
+    const stack = new Stack<number>();
+
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+
+    expect(stack.peek().data).toBe(3);
+  });
+});

src/stack/__tests__/StackNode.test.ts

@@ -0,0 +1,27 @@
+import { StackNode } from '../StackNode';
+
+describe('Stack Node', () => {
+  test('create empty stack node', () => {
+    const node = new StackNode();
+
+    expect(node.data).toBeUndefined();
+    expect(node.next).toBeNull();
+    expect(node.next).toBeNull();
+  });
+
+  test('create stack node with value', () => {
+    const node = new StackNode(10);
+
+    expect(node.data).toBe(10);
+    expect(node.next).toBeNull();
+  });
+
+  test('create stack node with object as a value', () => {
+    const nodeValue = { key: 1, value: 'test' };
+    const node = new StackNode(nodeValue);
+
+    expect(node.data.key).toBe(1);
+    expect(node.data.value).toBe('test');
+    expect(node.next).toBeNull();
+  });
+});