@gabrielrufino/cube 1.0.1 → 1.0.6

package/src/BinarySearchTree/index.spec.ts

@@ -1,486 +0,0 @@
-import {describe, it, expect, jest} from '@jest/globals';
-import faker from 'faker';
-
-import BinarySearchTree from './';
-
-describe('BinarySearchTree', () => {
-	it('Should create an empty bst without problems', () => {
-		const bst = new BinarySearchTree();
-
-		expect(bst.data).toEqual({
-			left: null,
-			value: null,
-			right: null,
-		});
-		expect(bst.size).toBe(0);
-	});
-
-	it('Should create a filled bst without problems', () => {
-		const bst = new BinarySearchTree<number>({
-			inputs: [4, 2, 1, 3, 5],
-		});
-
-		expect(bst.data).toEqual({
-			left: {
-				left: {
-					left: null,
-					value: 1,
-					right: null,
-				},
-				value: 2,
-				right: {
-					left: null,
-					value: 3,
-					right: null,
-				},
-			},
-			value: 4,
-			right: {
-				left: null,
-				value: 5,
-				right: null,
-			},
-		});
-		expect(bst.size).toBe(5);
-	});
-
-	it('Should allow us to customize the comparison function', () => {
-		const bst = new BinarySearchTree<any[]>({
-			lessThanOrEqualTo: (value1: any[], value2: any[]) => {
-				if (value1.length <= value2.length) {
-					return true;
-				}
-
-				return false;
-			},
-			inputs: [
-				['one', 'two'],
-				['one'],
-				['one', 'two', 'three'],
-			],
-		});
-
-		expect(bst.data).toEqual({
-			left: {
-				left: null,
-				value: ['one'],
-				right: null,
-			},
-			value: ['one', 'two'],
-			right: {
-				left: null,
-				value: ['one', 'two', 'three'],
-				right: null,
-			},
-		});
-		expect(bst.size).toBe(3);
-	});
-
-	describe('.insert()', () => {
-		it('Should insert a new value in the root when the root is null', () => {
-			const bst = new BinarySearchTree();
-			bst.insert(1);
-
-			expect(bst.data).toEqual({
-				left: null,
-				value: 1,
-				right: null,
-			});
-			expect(bst.size).toBe(1);
-		});
-
-		it('Should insert a new value in the left of the root when the new value is less than the root value', () => {
-			const bst = new BinarySearchTree({
-				inputs: [2],
-			});
-			bst.insert(1);
-
-			expect(bst.data).toEqual({
-				left: {
-					left: null,
-					value: 1,
-					right: null,
-				},
-				value: 2,
-				right: null,
-			});
-			expect(bst.size).toBe(2);
-		});
-
-		it('Should insert a new value in the left of the root when the new value is equal to the root value', () => {
-			const bst = new BinarySearchTree({
-				inputs: [1],
-			});
-			bst.insert(1);
-
-			expect(bst.data).toEqual({
-				left: {
-					left: null,
-					value: 1,
-					right: null,
-				},
-				value: 1,
-				right: null,
-			});
-			expect(bst.size).toBe(2);
-		});
-
-		it('Should insert a new value in the right of the root when the new value is greater than the root value', () => {
-			const bst = new BinarySearchTree({
-				inputs: [1],
-			});
-			bst.insert(2);
-
-			expect(bst.data).toEqual({
-				left: null,
-				value: 1,
-				right: {
-					left: null,
-					value: 2,
-					right: null,
-				},
-			});
-			expect(bst.size).toBe(2);
-		});
-
-		it('Should return the inserted value', () => {
-			const bst = new BinarySearchTree();
-			const value = faker.datatype.number();
-			const returned = bst.insert(value);
-
-			expect(returned).toBe(value);
-		});
-	});
-
-	describe('.walkInOrder()', () => {
-		it('Should walk the tree in order', () => {
-			const bst = new BinarySearchTree({
-				inputs: [3, 8, 4, 2, 5, 9, 1, 6, 10, 7],
-			});
-
-			const calls: number[] = [];
-			const callback = (value: number) => {
-				calls.push(value);
-			};
-
-			bst.walkInOrder(callback);
-
-			expect(calls).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-		});
-
-		it('Should call the callback function with correct arguments', () => {
-			const inputs = [3, 8, 4, 2, 5, 9, 1, 6, 10, 7];
-			const bst = new BinarySearchTree({
-				inputs,
-			});
-			const callback = jest.fn();
-			bst.walkInOrder(callback);
-
-			for (const value of inputs) {
-				expect(callback).toBeCalledWith(value);
-			}
-		});
-	});
-
-	describe('.walkPreOrder()', () => {
-		it('Should walk the tree pre order', () => {
-			const bst = new BinarySearchTree({
-				inputs: [3, 8, 4, 2, 5, 9, 1, 6, 10, 7],
-			});
-
-			const calls: number[] = [];
-			const callback = (value: number) => {
-				calls.push(value);
-			};
-
-			bst.walkPreOrder(callback);
-
-			expect(calls).toEqual([3, 2, 1, 8, 4, 5, 6, 7, 9, 10]);
-		});
-
-		it('Should call the callback function with correct arguments', () => {
-			const inputs = [3, 8, 4, 2, 5, 9, 1, 6, 10, 7];
-			const bst = new BinarySearchTree({
-				inputs,
-			});
-			const callback = jest.fn();
-			bst.walkPreOrder(callback);
-
-			for (const value of inputs) {
-				expect(callback).toBeCalledWith(value);
-			}
-		});
-	});
-
-	describe('.walkPostOrder()', () => {
-		it('Should walk the tree pre order', () => {
-			const bst = new BinarySearchTree({
-				inputs: [3, 8, 4, 2, 5, 9, 1, 6, 10, 7],
-			});
-
-			const calls: number[] = [];
-			const callback = (value: number) => {
-				calls.push(value);
-			};
-
-			bst.walkPostOrder(callback);
-
-			expect(calls).toEqual([1, 2, 7, 6, 5, 4, 10, 9, 8, 3]);
-		});
-
-		it('Should call the callback function with correct arguments', () => {
-			const inputs = [3, 8, 4, 2, 5, 9, 1, 6, 10, 7];
-			const bst = new BinarySearchTree({
-				inputs,
-			});
-			const callback = jest.fn();
-			bst.walkPostOrder(callback);
-
-			for (const value of inputs) {
-				expect(callback).toBeCalledWith(value);
-			}
-		});
-	});
-
-	describe('.min', () => {
-		it('Should return null when the bst in empty', () => {
-			const bst = new BinarySearchTree();
-
-			expect(bst.min).toBeNull();
-		});
-
-		it('Should return the minimum value of the bst', () => {
-			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
-			const bst = new BinarySearchTree({
-				inputs,
-			});
-
-			expect(bst.min).toBe(Math.min(...inputs));
-		});
-	});
-
-	describe('.max', () => {
-		it('Should return null when the bst in empty', () => {
-			const bst = new BinarySearchTree();
-
-			expect(bst.max).toBeNull();
-		});
-
-		it('Should return the maximum value of the bst', () => {
-			const inputs = new Array(10).fill(undefined).map(faker.datatype.number);
-			const bst = new BinarySearchTree({
-				inputs,
-			});
-
-			expect(bst.max).toBe(Math.max(...inputs));
-		});
-	});
-
-	describe('.search()', () => {
-		it('Should return true when the received value is in the bst', () => {
-			const bst = new BinarySearchTree({
-				inputs: [3, 2, 4, 1],
-			});
-			const returned = bst.search(2);
-
-			expect(returned).toBe(true);
-		});
-
-		it('Should return false whe the received value is not in the bst', () => {
-			const bst = new BinarySearchTree({
-				inputs: [3, 2, 4, 1],
-			});
-			const returned = bst.search(5);
-
-			expect(returned).toBe(false);
-		});
-	});
-
-	describe('.remove()', () => {
-		it('Should remove a node that is a leaf', () => {
-			const bst = new BinarySearchTree({
-				inputs: [4, 5, 2, 7, 6, 1],
-			});
-			bst.remove(6);
-
-			expect(bst.data).toEqual({
-				left: {
-					left: {
-						left: null,
-						value: 1,
-						right: null,
-					},
-					value: 2,
-					right: null,
-				},
-				value: 4,
-				right: {
-					left: null,
-					value: 5,
-					right: {
-						left: null,
-						value: 7,
-						right: null,
-					},
-				},
-			});
-			expect(bst.size).toBe(5);
-		});
-
-		it('Should remove a node that has a right child', () => {
-			const bst = new BinarySearchTree({
-				inputs: [4, 5, 2, 7, 6, 1],
-			});
-			bst.remove(5);
-
-			expect(bst.data).toEqual({
-				left: {
-					left: {
-						left: null,
-						value: 1,
-						right: null,
-					},
-					value: 2,
-					right: null,
-				},
-				value: 4,
-				right: {
-					left: {
-						left: null,
-						value: 6,
-						right: null,
-					},
-					value: 7,
-					right: null,
-				},
-			});
-			expect(bst.size).toBe(5);
-		});
-
-		it('Should remove a node that has a left child', () => {
-			const bst = new BinarySearchTree({
-				inputs: [4, 5, 2, 7, 6, 1],
-			});
-			bst.remove(2);
-
-			expect(bst.data).toEqual({
-				left: {
-					left: null,
-					right: null,
-					value: 1,
-				},
-				value: 4,
-				right: {
-					left: null,
-					value: 5,
-					right: {
-						left: {
-							left: null,
-							value: 6,
-							right: null,
-						},
-						value: 7,
-						right: null,
-					},
-				},
-			});
-			expect(bst.size).toBe(5);
-		});
-
-		it('Should remove a node thar has a left child and a right child', () => {
-			const bst = new BinarySearchTree({
-				inputs: [4, 5, 2, 7, 6, 1, 3, 2.5, 2.1, 3.5],
-			});
-			bst.remove(2);
-
-			expect(bst.data).toEqual({
-				left: {
-					left: {
-						left: null,
-						value: 1,
-						right: null,
-					},
-					value: 2.1,
-					right: {
-						left: {
-							left: null,
-							value: 2.5,
-							right: null,
-						},
-						value: 3,
-						right: {
-							left: null,
-							value: 3.5,
-							right: null,
-						},
-					},
-				},
-				value: 4,
-				right: {
-					left: null,
-					value: 5,
-					right: {
-						left: {
-							left: null,
-							value: 6,
-							right: null,
-						},
-						value: 7,
-						right: null,
-					},
-				},
-			});
-			expect(bst.size).toBe(9);
-		});
-
-		it('Should remove the root', () => {
-			const bst = new BinarySearchTree({
-				inputs: [4, 5, 2, 7, 6, 1],
-			});
-			bst.remove(4);
-
-			expect(bst.data).toEqual({
-				left: {
-					left: {
-						left: null,
-						value: 1,
-						right: null,
-					},
-					value: 2,
-					right: null,
-				},
-				value: 5,
-				right: {
-					left: {
-						left: null,
-						value: 6,
-						right: null,
-					},
-					value: 7,
-					right: null,
-				},
-			});
-			expect(bst.size).toBe(5);
-		});
-	});
-
-	describe('Conversion to primitive', () => {
-		it('Should return arrow separated values in string conversion', () => {
-			const bst = new BinarySearchTree({
-				inputs: [4, 2, 1, 3, 6, 5, 7],
-			});
-			const string = String(bst);
-
-			expect(string).toBe('[[[null] <= (1) => [null]] <= (2) => [[null] <= (3) => [null]]] <= (4) => [[[null] <= (5) => [null]] <= (6) => [[null] <= (7) => [null]]]');
-		});
-
-		it('Should return the size in number conversion', () => {
-			const bst = new BinarySearchTree({
-				inputs: [4, 2, 1, 3, 6, 5, 7],
-			});
-			const number = Number(bst);
-
-			expect(number).toBe(7);
-		});
-	});
-});

package/src/BinarySearchTree/index.ts

@@ -1,198 +0,0 @@
-import BinarySearchTreeNode from './BinarySearchTreeNode';
-import IBinarySearchNodeOptions from './IBinarySearchNodeOptions';
-import IBinarySearchTree from './IBinarySearchTree';
-import IBinarySearchTreeData from './IBinarySearchTreeData';
-
-export default class BinarySearchTree<T = number> implements IBinarySearchTree<T> {
-	private _root: BinarySearchTreeNode<T> | null = null;
-	private _size: number = 0;
-
-	constructor({inputs = [], lessThanOrEqualTo}: IBinarySearchNodeOptions<T> = {inputs: []}) {
-		if (lessThanOrEqualTo) {
-			this._lessThanOrEqualTo = lessThanOrEqualTo;
-		}
-
-		for (const value of inputs) {
-			this.insert(value);
-		}
-
-		this._size = inputs.length;
-	}
-
-	get data(): IBinarySearchTreeData<T> {
-		return this._root || {
-			left: null,
-			value: null,
-			right: null,
-		};
-	}
-
-	get size(): number {
-		return this._size;
-	}
-
-	get min(): T | null {
-		let current = this._root;
-
-		while (current && current.left) {
-			current = current.left;
-		}
-
-		return current?.value || null;
-	}
-
-	get max(): T | null {
-		let current = this._root;
-
-		while (current && current.right) {
-			current = current.right;
-		}
-
-		return current?.value || null;
-	}
-
-	public insert(value: T): T {
-		const node = new BinarySearchTreeNode(value);
-
-		if (this._root) {
-			this._insertChild(this._root, node);
-		} else {
-			this._root = node;
-		}
-
-		this._size += 1;
-
-		return value;
-	}
-
-	public walkInOrder(callback: (_value: T) => any): void {
-		this._visitNodeInOrder(this._root, callback);
-	}
-
-	public walkPreOrder(callback: (_value: T) => any): void {
-		this._visitNodePreOrder(this._root, callback);
-	}
-
-	public walkPostOrder(callback: (_value: T) => any): void {
-		this._visitNodePostOrder(this._root, callback);
-	}
-
-	public search(value: T): boolean {
-		let current = this._root;
-
-		while (current && current.value !== value) {
-			if (this._lessThanOrEqualTo(value, current.value)) {
-				current = current.left;
-			} else {
-				current = current.right;
-			}
-		}
-
-		return Boolean(current);
-	}
-
-	public remove(value: T): T | null {
-		let current = this._root;
-		const path: Array<'left' | 'right'> = [];
-
-		while (current && current.value !== value) {
-			if (this._lessThanOrEqualTo(value, current.value)) {
-				current = current.left;
-				path.push('left');
-			} else {
-				current = current.right;
-				path.push('right');
-			}
-		}
-
-		const found = {...current};
-		const parent = path
-			.slice(0, path.length - 1)
-			.reduce((accumulator, current) => accumulator && accumulator[current], this._root);
-		const child = path[path.length - 1];
-
-		if (current?.left && current?.right && parent) {
-			let head = current.right;
-
-			while (head.left) {
-				head = head.left;
-			}
-
-			this.remove(head.value);
-			current.value = head.value;
-		} else if (current?.left && parent) {
-			parent[child] = current.left;
-			this._size -= 1;
-		} else if (current?.right && parent) {
-			parent[child] = current.right;
-			this._size -= 1;
-		} else if (parent) {
-			parent[child] = null;
-			this._size -= 1;
-		}
-
-		return found.value || null;
-	}
-
-	private _lessThanOrEqualTo(value1: T, value2: T): boolean {
-		if (value1 <= value2) {
-			return true;
-		}
-
-		return false;
-	}
-
-	private _insertChild(father: BinarySearchTreeNode<T>, child: BinarySearchTreeNode<T>): void {
-		if (this._lessThanOrEqualTo(child.value, father.value)) {
-			if (father.left) {
-				this._insertChild(father.left, child);
-			} else {
-				father.left = child;
-			}
-
-			return;
-		}
-
-		if (father.right) {
-			this._insertChild(father.right, child);
-		} else {
-			father.right = child;
-		}
-	}
-
-	private _visitNodeInOrder(node: BinarySearchTreeNode<T> | null, callback: (_value: T) => any): void {
-		if (node) {
-			this._visitNodeInOrder(node.left, callback);
-			callback(node.value);
-			this._visitNodeInOrder(node.right, callback);
-		}
-	}
-
-	private _visitNodePreOrder(node: BinarySearchTreeNode<T> | null, callback: (_value: T) => any): void {
-		if (node) {
-			callback(node.value);
-			this._visitNodePreOrder(node.left, callback);
-			this._visitNodePreOrder(node.right, callback);
-		}
-	}
-
-	private _visitNodePostOrder(node: BinarySearchTreeNode<T> | null, callback: (_value: T) => any): void {
-		if (node) {
-			this._visitNodePostOrder(node.left, callback);
-			this._visitNodePostOrder(node.right, callback);
-			callback(node.value);
-		}
-	}
-
-	private [Symbol.toPrimitive](type: string): string | number | null {
-		if (type === 'string') {
-			return `${this._root}`;
-		}
-
-		if (type === 'number') {
-			return this.size;
-		}
-
-		return null;
-	}
-}

package/src/DataStructure/index.spec.ts

@@ -1,25 +0,0 @@
-import {describe, expect, it} from '@jest/globals';
-
-import DataStructure from './';
-
-describe('DataStructure', () => {
-	class Something<T = number> extends DataStructure<T> {
-		constructor(...inputs: T[]) {
-			super(inputs);
-		}
-	}
-
-	it('Should create an empty Something with no problems', () => {
-		const something = new Something();
-
-		expect(something.data).toEqual([]);
-		expect(something.size).toBe(0);
-	});
-
-	it('Should create a filled Something with no problems', () => {
-		const something = new Something(1, 2, 3, 4);
-
-		expect(something.data).toEqual([1, 2, 3, 4]);
-		expect(something.size).toBe(4);
-	});
-});

package/src/DataStructure/index.ts

@@ -1,15 +0,0 @@
-export default abstract class DataStructure<T> {
-	protected _data: T[];
-
-	constructor(inputs: T[]) {
-		this._data = [...inputs];
-	}
-
-	public get data(): T[] {
-		return [...this._data];
-	}
-
-	public get size(): number {
-		return this._data.length;
-	}
-}