@gabrielrufino/cube 1.0.1

package/src/BinarySearchTree/index.spec.ts

@@ -0,0 +1,486 @@
+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

@@ -0,0 +1,198 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,15 @@
+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;
+	}
+}