@gabrielrufino/cube 1.0.1

package/src/LinkedList/index.ts

@@ -0,0 +1,185 @@
+import ILinkedList from './ILinkedList';
+import Node from './Node';
+
+export default class LinkedList<T = number> implements ILinkedList<T> {
+	private readonly _FIRST_POSITION = 0;
+	private _head: Node<T> | null = null;
+	private _size: number = 0;
+
+	constructor(...inputs: T[]) {
+		if (inputs.length) {
+			const nodes = inputs.map(input => new Node<T>(input));
+
+			for (let i = 0; i < inputs.length - 1; i++) {
+				nodes[i].next = nodes[i + 1];
+			}
+
+			this._head = nodes[0];
+			this._size = nodes.length;
+		}
+	}
+
+	public get data() {
+		const data = [];
+
+		let current = this._head;
+
+		while (current) {
+			data.push({
+				value: current.value,
+				next: current.next?.value || null,
+			});
+
+			current = current.next;
+		}
+
+		return data;
+	}
+
+	public get size() {
+		return this._size;
+	}
+
+	public get isEmpty() {
+		return this.size === 0;
+	}
+
+	public positionOf(element: T): number | undefined {
+		let current = this._head;
+		let position = 0;
+
+		while (current && current.value !== element) {
+			current = current?.next;
+			position += 1;
+		}
+
+		if (current) {
+			return position;
+		}
+	}
+
+	public push(element: T): T {
+		if (this._head) {
+			let current: Node<T> = this._head;
+
+			while (current.next) {
+				current = current.next;
+			}
+
+			current.next = new Node<T>(element);
+		} else {
+			this._head = new Node<T>(element);
+		}
+
+		this._size += 1;
+
+		return element;
+	}
+
+	public remove(element: T): T | undefined {
+		const position = this.positionOf(element);
+
+		if (position) {
+			return this.removeFromPosition(position);
+		}
+	}
+
+	public insertInPosition(element: T, position: number): T | undefined {
+		if (position < this._FIRST_POSITION || position > this.size) {
+			return undefined;
+		}
+
+		const node = new Node<T>(element);
+
+		if (position === this._FIRST_POSITION) {
+			node.next = this._head;
+			this._head = node;
+		} else {
+			const before = this.getNodeFromPosition(position - 1);
+			const after = (before && before.next) || null;
+
+			if (before) {
+				before.next = node;
+			}
+
+			node.next = after;
+		}
+
+		this._size += 1;
+
+		return element;
+	}
+
+	public getFromPosition(position: number) {
+		if (position < this._FIRST_POSITION || position > this.size - 1) {
+			return undefined;
+		}
+
+		let node = this._head;
+
+		for (let i = 0; i < position; i++) {
+			node = node?.next || null;
+		}
+
+		if (node?.value) {
+			return {
+				value: node.value,
+				next: node.next?.value || null,
+			};
+		}
+
+		return undefined;
+	}
+
+	public removeFromPosition(position: number): T | undefined {
+		if (position < this._FIRST_POSITION || position > (this.size - 1)) {
+			return undefined;
+		}
+
+		let current: Node<T> | null = this._head;
+
+		if (position === this._FIRST_POSITION) {
+			this._head = current?.next || null;
+		} else {
+			let previous: Node<T> | null | undefined;
+
+			for (let i = 0; i < position; i++) {
+				previous = current;
+				current = current?.next || null;
+			}
+
+			if (previous) {
+				previous.next = current?.next || null;
+			}
+		}
+
+		this._size -= 1;
+		return current?.value;
+	}
+
+	private getNodeFromPosition(position: number): Node<T> | undefined {
+		if (position < this._FIRST_POSITION || position > this.size - 1) {
+			return undefined;
+		}
+
+		let node = this._head;
+
+		for (let i = 0; i < position; i++) {
+			node = node?.next || null;
+		}
+
+		return node || undefined;
+	}
+
+	private [Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `[Head] ${this.data.map(({value}) => value).join(' => ')}`;
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/List/index.ts

@@ -0,0 +1 @@
+export {default} from '../Array';

package/src/MaxHeap/IMaxHeap.ts

@@ -0,0 +1,10 @@
+interface IMaxHeap<T> {
+    get data(): T[];
+    get size(): number;
+    get isEmpty(): boolean;
+    get max(): T | null;
+    insert(_value: T): T;
+    extract(): T | null;
+}
+
+export default IMaxHeap;

package/src/MaxHeap/IMaxHeapOptions.ts

@@ -0,0 +1,6 @@
+interface IMaxHeapOptions<T> {
+	greaterThanOrEqualTo?: (_value1: T, _value2: T) => boolean;
+	inputs?: T[],
+}
+
+export default IMaxHeapOptions;

package/src/MaxHeap/index.spec.ts

@@ -0,0 +1,161 @@
+import {describe, it, expect} from '@jest/globals';
+import faker from 'faker';
+
+import MaxHeap from './';
+
+describe('MaxHeap', () => {
+	it('Should create an empty max heap without problems', () => {
+		const maxHeap = new MaxHeap();
+
+		expect(maxHeap.data).toEqual([]);
+		expect(maxHeap.size).toBe(0);
+	});
+
+	it('Should create a filled max heap without problems', () => {
+		const maxHeap = new MaxHeap({
+			inputs: [5, 2, 1, 9],
+		});
+
+		expect(maxHeap.data).toEqual([9, 5, 1, 2]);
+		expect(maxHeap.size).toBe(4);
+	});
+
+	describe('.isEmpty', () => {
+		it('Should be true when the heap has no values', () => {
+			const maxHeap = new MaxHeap();
+
+			expect(maxHeap.isEmpty).toBe(true);
+		});
+
+		it('Should be false when the heap has at least one value', () => {
+			const maxHeap = new MaxHeap({
+				inputs: [faker.datatype.number()],
+			});
+
+			expect(maxHeap.isEmpty).toBe(false);
+		});
+	});
+
+	describe('.max', () => {
+		it('Should be the min value when the heap is not empty', () => {
+			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
+			const maxHeap = new MaxHeap({
+				inputs,
+			});
+
+			expect(maxHeap.max).toBe(Math.max(...inputs));
+		});
+
+		it('Should be null when the heap is empty', () => {
+			const maxHeap = new MaxHeap();
+
+			expect(maxHeap.max).toBeNull();
+		});
+	});
+
+	describe('.insert()', () => {
+		it('Should insert new values in the heap', () => {
+			const maxHeap = new MaxHeap();
+
+			maxHeap.insert(5);
+			expect(maxHeap.data).toEqual([5]);
+			expect(maxHeap.size).toBe(1);
+
+			maxHeap.insert(2);
+			expect(maxHeap.data).toEqual([5, 2]);
+			expect(maxHeap.size).toBe(2);
+
+			maxHeap.insert(1);
+			expect(maxHeap.data).toEqual([5, 2, 1]);
+			expect(maxHeap.size).toBe(3);
+
+			maxHeap.insert(9);
+			expect(maxHeap.data).toEqual([9, 5, 1, 2]);
+			expect(maxHeap.size).toBe(4);
+		});
+
+		it('Should return the inserted value', () => {
+			const maxHeap = new MaxHeap();
+			const value = faker.datatype.number();
+			const returned = maxHeap.insert(value);
+
+			expect(returned).toBe(value);
+		});
+	});
+
+	describe('.extract()', () => {
+		it('Should extract the max value of the heap and adjust the heap after this', () => {
+			const maxHeap = new MaxHeap({
+				inputs: [9, 8, 7, 6, 5, 4, 3, 2, 1],
+			});
+			maxHeap.extract();
+
+			expect(maxHeap.data).toEqual([8, 6, 7, 2, 5, 4, 3, 1]);
+			expect(maxHeap.size).toBe(8);
+		});
+
+		it('Should return the extracted value', () => {
+			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
+			const maxHeap = new MaxHeap({inputs});
+			const returned = maxHeap.extract();
+
+			expect(returned).toBe(Math.max(...inputs));
+		});
+
+		it('Should change nothing if the heap is empty', () => {
+			const maxHeap = new MaxHeap();
+			maxHeap.extract();
+
+			expect(maxHeap.data).toEqual([]);
+			expect(maxHeap.size).toBe(0);
+		});
+	});
+
+	describe('Heap Sort', () => {
+		it('Should sort an array in DESC order', () => {
+			const maxHeap = new MaxHeap({
+				inputs: [
+					7,
+					1,
+					10,
+					4,
+					8,
+					6,
+					2,
+					3,
+					5,
+					9,
+				],
+			});
+
+			const {size} = maxHeap;
+			const result = [];
+
+			for (let i = 1; i <= size; i++) {
+				result.push(maxHeap.extract());
+			}
+
+			expect(result).toEqual([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return separated by comma values in string conversion', () => {
+			const maxHeap = new MaxHeap({
+				inputs: [1, 2, 3, 4, 5],
+			});
+			const string = String(maxHeap);
+
+			expect(string).toBe('5, 4, 2, 1, 3');
+		});
+
+		it('Should return the size in number conversion', () => {
+			const maxHeap = new MaxHeap({
+				inputs: [1, 2, 3, 4, 5],
+			});
+			const number = Number(maxHeap);
+
+			expect(number).toBe(5);
+		});
+	});
+});

package/src/MaxHeap/index.ts

@@ -0,0 +1,91 @@
+import IMaxHeap from './IMaxHeap';
+import IMaxHeapOptions from './IMaxHeapOptions';
+
+export default class MaxHeap<T = number> implements IMaxHeap<T> {
+	private _data: T[] = [];
+
+	constructor({greaterThanOrEqualTo, inputs = []}: IMaxHeapOptions<T> = {inputs: []}) {
+		if (greaterThanOrEqualTo) {
+			this._greaterThanOrEqualTo = greaterThanOrEqualTo;
+		}
+
+		for (const input of inputs) {
+			this.insert(input);
+		}
+	}
+
+	get data(): T[] {
+		return [...this._data];
+	}
+
+	get size(): number {
+		return this.data.length;
+	}
+
+	get isEmpty(): boolean {
+		return this.size === 0;
+	}
+
+	get max(): T | null {
+		return this.data[0] || null;
+	}
+
+	public insert(value: T): T {
+		this._data = [...this.data, value];
+		this._siftUp(this.size - 1);
+		return value;
+	}
+
+	public extract(): T | null {
+		if (!this.isEmpty) {
+			const [min, ...rest] = this.data;
+			this._data = [rest[rest.length - 1], ...rest.slice(0, rest.length - 1)].filter(value => value !== undefined);
+			this._siftDown(0);
+
+			return min;
+		}
+
+		return null;
+	}
+
+	private _greaterThanOrEqualTo = (value1: T, value2: T): boolean => value1 >= value2;
+	private _getLeftIndex = (index: number): number => (2 * index) + 1;
+	private _getRightIndex = (index: number): number => (2 * index) + 2;
+	private _getParentIndex = (index: number): number => Math.floor((index - 1) / 2);
+
+	private _siftUp(index: number): void {
+		const parent = this._getParentIndex(index);
+
+		if (index > 0 && this._greaterThanOrEqualTo(this.data[index], this.data[parent])) {
+			[this._data[parent], this._data[index]] = [this.data[index], this.data[parent]];
+			this._siftUp(parent);
+		}
+	}
+
+	private _siftDown(index: number): void {
+		const left = this._getLeftIndex(index);
+		const right = this._getRightIndex(index);
+
+		if (left < this.size && this._greaterThanOrEqualTo(this.data[left], this.data[index])) {
+			[this._data[left], this._data[index]] = [this.data[index], this.data[left]];
+			this._siftDown(left);
+		}
+
+		if (right < this.size && this._greaterThanOrEqualTo(this.data[right], this.data[index])) {
+			[this._data[right], this._data[index]] = [this.data[index], this.data[right]];
+			this._siftDown(right);
+		}
+	}
+
+	private [Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return this.data.join(', ');
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/MinHeap/IMinHeap.ts

@@ -0,0 +1,10 @@
+interface IMinHeap<T> {
+	get data(): T[];
+	get size(): number;
+	get isEmpty(): boolean;
+	get min(): T | null;
+	insert(_value: T): T;
+	extract(): T | null;
+}
+
+export default IMinHeap;

package/src/MinHeap/IMinHeapOptions.ts

@@ -0,0 +1,6 @@
+interface IMinHeapOptions<T> {
+	lessThanOrEqualTo?: (_value1: T, _value2: T) => boolean;
+	inputs?: T[],
+}
+
+export default IMinHeapOptions;

package/src/MinHeap/index.spec.ts

@@ -0,0 +1,161 @@
+import {describe, it, expect} from '@jest/globals';
+import faker from 'faker';
+
+import MinHeap from './';
+
+describe('MinHeap', () => {
+	it('Should create an empty min heap without problems', () => {
+		const minHeap = new MinHeap();
+
+		expect(minHeap.data).toEqual([]);
+		expect(minHeap.size).toBe(0);
+	});
+
+	it('Should create a filled min heap without problems', () => {
+		const minHeap = new MinHeap({
+			inputs: [5, 2, 1, 9],
+		});
+
+		expect(minHeap.data).toEqual([1, 5, 2, 9]);
+		expect(minHeap.size).toBe(4);
+	});
+
+	describe('.isEmpty', () => {
+		it('Should be true when the heap has no values', () => {
+			const minHeap = new MinHeap();
+
+			expect(minHeap.isEmpty).toBe(true);
+		});
+
+		it('Should be false when the heap has at least one value', () => {
+			const minHeap = new MinHeap({
+				inputs: [faker.datatype.number()],
+			});
+
+			expect(minHeap.isEmpty).toBe(false);
+		});
+	});
+
+	describe('.min', () => {
+		it('Should be the min value when the heap is not empty', () => {
+			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
+			const minHeap = new MinHeap({
+				inputs,
+			});
+
+			expect(minHeap.min).toBe(Math.min(...inputs));
+		});
+
+		it('Should be null when the heap is empty', () => {
+			const minHeap = new MinHeap();
+
+			expect(minHeap.min).toBeNull();
+		});
+	});
+
+	describe('.insert()', () => {
+		it('Should insert new values in the heap', () => {
+			const minHeap = new MinHeap();
+
+			minHeap.insert(5);
+			expect(minHeap.data).toEqual([5]);
+			expect(minHeap.size).toBe(1);
+
+			minHeap.insert(2);
+			expect(minHeap.data).toEqual([2, 5]);
+			expect(minHeap.size).toBe(2);
+
+			minHeap.insert(1);
+			expect(minHeap.data).toEqual([1, 5, 2]);
+			expect(minHeap.size).toBe(3);
+
+			minHeap.insert(9);
+			expect(minHeap.data).toEqual([1, 5, 2, 9]);
+			expect(minHeap.size).toBe(4);
+		});
+
+		it('Should return the inserted value', () => {
+			const minHeap = new MinHeap();
+			const value = faker.datatype.number();
+			const returned = minHeap.insert(value);
+
+			expect(returned).toBe(value);
+		});
+	});
+
+	describe('.extract()', () => {
+		it('Should extract the min value of the heap and adjust the heap after this', () => {
+			const minHeap = new MinHeap({
+				inputs: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			});
+			minHeap.extract();
+
+			expect(minHeap.data).toEqual([2, 4, 3, 8, 5, 6, 7, 9]);
+			expect(minHeap.size).toBe(8);
+		});
+
+		it('Should return the extracted value', () => {
+			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
+			const minHeap = new MinHeap({inputs});
+			const returned = minHeap.extract();
+
+			expect(returned).toBe(Math.min(...inputs));
+		});
+
+		it('Should change nothing if the heap is empty', () => {
+			const minHeap = new MinHeap();
+			minHeap.extract();
+
+			expect(minHeap.data).toEqual([]);
+			expect(minHeap.size).toBe(0);
+		});
+	});
+
+	describe('Heap Sort', () => {
+		it('Should sort an array in ASC order', () => {
+			const minHeap = new MinHeap({
+				inputs: [
+					7,
+					1,
+					10,
+					4,
+					8,
+					6,
+					2,
+					3,
+					5,
+					9,
+				],
+			});
+
+			const {size} = minHeap;
+			const result = [];
+
+			for (let i = 1; i <= size; i++) {
+				result.push(minHeap.extract());
+			}
+
+			expect(result).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return separated by comma values in string conversion', () => {
+			const maxHeap = new MinHeap({
+				inputs: [1, 2, 3, 4, 5],
+			});
+			const string = String(maxHeap);
+
+			expect(string).toBe('1, 2, 3, 4, 5');
+		});
+
+		it('Should return the size in number conversion', () => {
+			const maxHeap = new MinHeap({
+				inputs: [1, 2, 3, 4, 5],
+			});
+			const number = Number(maxHeap);
+
+			expect(number).toBe(5);
+		});
+	});
+});