@gabrielrufino/cube 1.0.1

package/build/Queue/index.d.ts

@@ -0,0 +1,11 @@
+import DataStructure from '../DataStructure';
+import IQueue from './IQueue';
+export default class Queue<T = number> extends DataStructure<T> implements IQueue<T> {
+    constructor(...inputs: T[]);
+    get isEmpty(): boolean;
+    enqueue(element: T): T;
+    dequeue(): T | undefined;
+    peek(): T | undefined;
+    clear(): void;
+    private [Symbol.toPrimitive];
+}

package/build/Queue/index.js

@@ -0,0 +1,74 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var DataStructure_1 = __importDefault(require("../DataStructure"));
+var Queue = /** @class */ (function (_super) {
+    __extends(Queue, _super);
+    function Queue() {
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            inputs[_i] = arguments[_i];
+        }
+        return _super.call(this, inputs) || this;
+    }
+    Object.defineProperty(Queue.prototype, "isEmpty", {
+        get: function () {
+            return this.size === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Queue.prototype.enqueue = function (element) {
+        this._data = __spreadArray(__spreadArray([], this.data, true), [element], false);
+        return element;
+    };
+    Queue.prototype.dequeue = function () {
+        var _a = this.data, element = _a[0], rest = _a.slice(1);
+        this._data = rest;
+        return element;
+    };
+    Queue.prototype.peek = function () {
+        var element = this.data[0];
+        return element;
+    };
+    Queue.prototype.clear = function () {
+        this._data = [];
+    };
+    Queue.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "[Front] ".concat(this.data.join(', '));
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return Queue;
+}(DataStructure_1.default));
+exports.default = Queue;

package/build/Set/ISet.d.ts

@@ -0,0 +1,15 @@
+import Set from './';
+interface ISet<T> {
+    get data(): T[];
+    get size(): number;
+    has(_elemet: T): boolean;
+    add(_element: T): T | null;
+    delete(_element: T): T | null;
+    clear(_element: T): T[];
+    union(_set: Set<T>): Set<T>;
+    intersection(_set: Set<T>): Set<T>;
+    difference(_set: Set<T>): Set<T>;
+    isSubsetOf(_set: Set<T>): boolean;
+    contains(_set: Set<T>): boolean;
+}
+export default ISet;

package/build/Set/ISet.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/Set/index.d.ts

@@ -0,0 +1,21 @@
+import ISet from './ISet';
+export default class Set<T = number> implements ISet<T> {
+    private _data;
+    constructor(...inputs: T[]);
+    get data(): T[];
+    get size(): number;
+    has(element: T): boolean;
+    add(element: T): T | null;
+    delete(element: T): T | null;
+    clear(): T[];
+    union(set: Set<T>): Set<T>;
+    intersection(set: Set<T>): Set<T>;
+    difference(set: Set<T>): Set<T>;
+    isSubsetOf(set: Set<T>): boolean;
+    contains(set: Set<T>): boolean;
+    static union<T>(set1: Set<T>, set2: Set<T>): Set<T>;
+    static intersection<T>(set1: Set<T>, set2: Set<T>): Set<T>;
+    static difference<T>(set1: Set<T>, set2: Set<T>): Set<T>;
+    static isSubset<T>(set1: Set<T>, set2: Set<T>): boolean;
+    private [Symbol.toPrimitive];
+}

package/build/Set/index.js

@@ -0,0 +1,132 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Set = /** @class */ (function () {
+    function Set() {
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            inputs[_i] = arguments[_i];
+        }
+        this._data = new Map();
+        for (var _a = 0, inputs_1 = inputs; _a < inputs_1.length; _a++) {
+            var input = inputs_1[_a];
+            this.add(input);
+        }
+    }
+    Object.defineProperty(Set.prototype, "data", {
+        get: function () {
+            return Array.from(this._data.values());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Set.prototype, "size", {
+        get: function () {
+            return this._data.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Set.prototype.has = function (element) {
+        return this._data.has(element);
+    };
+    Set.prototype.add = function (element) {
+        if (!this.has(element)) {
+            this._data.set(element, element);
+            return element;
+        }
+        return null;
+    };
+    Set.prototype.delete = function (element) {
+        if (this.has(element)) {
+            this._data.delete(element);
+            return element;
+        }
+        return null;
+    };
+    Set.prototype.clear = function () {
+        var elements = __spreadArray([], this.data, true);
+        this._data.clear();
+        return elements;
+    };
+    Set.prototype.union = function (set) {
+        return Set.union(this, set);
+    };
+    Set.prototype.intersection = function (set) {
+        return Set.intersection(this, set);
+    };
+    Set.prototype.difference = function (set) {
+        return Set.difference(this, set);
+    };
+    Set.prototype.isSubsetOf = function (set) {
+        return Set.isSubset(this, set);
+    };
+    Set.prototype.contains = function (set) {
+        return Set.isSubset(set, this);
+    };
+    Set.union = function (set1, set2) {
+        var union = new Set();
+        for (var _i = 0, _a = __spreadArray(__spreadArray([], set1.data, true), set2.data, true); _i < _a.length; _i++) {
+            var element = _a[_i];
+            union.add(element);
+        }
+        return union;
+    };
+    Set.intersection = function (set1, set2) {
+        var biggestSet;
+        var smallestSet;
+        if (set1.size >= set2.size) {
+            biggestSet = set1;
+            smallestSet = set2;
+        }
+        else {
+            biggestSet = set2;
+            smallestSet = set1;
+        }
+        var intersection = new Set();
+        for (var _i = 0, _a = smallestSet.data; _i < _a.length; _i++) {
+            var element = _a[_i];
+            if (biggestSet.has(element)) {
+                intersection.add(element);
+            }
+        }
+        return intersection;
+    };
+    Set.difference = function (set1, set2) {
+        var difference = new Set();
+        for (var _i = 0, _a = set1.data; _i < _a.length; _i++) {
+            var element = _a[_i];
+            if (!set2.has(element)) {
+                difference.add(element);
+            }
+        }
+        return difference;
+    };
+    Set.isSubset = function (set1, set2) {
+        if (set1.size > set2.size) {
+            return false;
+        }
+        return set1
+            .data
+            .every(function (element) { return set2.has(element); });
+    };
+    Set.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "{ ".concat(this.data.join(', '), " }");
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return Set;
+}());
+exports.default = Set;

package/build/Stack/IStack.d.ts

@@ -0,0 +1,8 @@
+interface IStack<T> {
+    push(_element: T): T;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    clear(): void;
+    get isEmpty(): boolean;
+}
+export default IStack;

package/build/Stack/IStack.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/Stack/index.d.ts

@@ -0,0 +1,11 @@
+import DataStructure from '../DataStructure';
+import IStack from './IStack';
+export default class Stack<T = number> extends DataStructure<T> implements IStack<T> {
+    constructor(...inputs: T[]);
+    push(element: T): T;
+    pop(): T | undefined;
+    peek(): T | undefined;
+    clear(): void;
+    get isEmpty(): boolean;
+    private [Symbol.toPrimitive];
+}

package/build/Stack/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var DataStructure_1 = __importDefault(require("../DataStructure"));
+var Stack = /** @class */ (function (_super) {
+    __extends(Stack, _super);
+    function Stack() {
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            inputs[_i] = arguments[_i];
+        }
+        return _super.call(this, inputs) || this;
+    }
+    Stack.prototype.push = function (element) {
+        this._data.push(element);
+        return element;
+    };
+    Stack.prototype.pop = function () {
+        var element = this._data.pop();
+        return element;
+    };
+    Stack.prototype.peek = function () {
+        var topPosition = this.data.length - 1;
+        return this.data[topPosition];
+    };
+    Stack.prototype.clear = function () {
+        this._data = [];
+    };
+    Object.defineProperty(Stack.prototype, "isEmpty", {
+        get: function () {
+            return this.data.length === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Stack.prototype[Symbol.toPrimitive] = function (type) {
+        if (type === 'string') {
+            return "".concat(this.data.join(', '), " [Top]");
+        }
+        if (type === 'number') {
+            return this.size;
+        }
+        return null;
+    };
+    return Stack;
+}(DataStructure_1.default));
+exports.default = Stack;

package/build/index.d.ts

@@ -0,0 +1,17 @@
+export { default as Algorithms } from './Algorithms';
+export { default as Array } from './Array';
+export { default as BinarySearchTree } from './BinarySearchTree';
+export { default as Deck } from './Deck';
+export { default as Dictionary } from './Dictionary';
+export { default as DoublyLinkedList } from './DoublyLinkedList';
+export { default as Graph } from './Graph';
+export { default as HashTable } from './HashTable';
+export { default as HashTableLinearProbing } from './HashTableLinearProbing';
+export { default as HashTableSeparateChaining } from './HashTableSeparateChaining';
+export { default as LinkedList } from './LinkedList';
+export { default as List } from './List';
+export { default as MaxHeap } from './MaxHeap';
+export { default as MinHeap } from './MinHeap';
+export { default as Queue } from './Queue';
+export { default as Set } from './Set';
+export { default as Stack } from './Stack';

package/build/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stack = exports.Set = exports.Queue = exports.MinHeap = exports.MaxHeap = exports.List = exports.LinkedList = exports.HashTableSeparateChaining = exports.HashTableLinearProbing = exports.HashTable = exports.Graph = exports.DoublyLinkedList = exports.Dictionary = exports.Deck = exports.BinarySearchTree = exports.Array = exports.Algorithms = void 0;
+var Algorithms_1 = require("./Algorithms");
+Object.defineProperty(exports, "Algorithms", { enumerable: true, get: function () { return __importDefault(Algorithms_1).default; } });
+var Array_1 = require("./Array");
+Object.defineProperty(exports, "Array", { enumerable: true, get: function () { return __importDefault(Array_1).default; } });
+var BinarySearchTree_1 = require("./BinarySearchTree");
+Object.defineProperty(exports, "BinarySearchTree", { enumerable: true, get: function () { return __importDefault(BinarySearchTree_1).default; } });
+var Deck_1 = require("./Deck");
+Object.defineProperty(exports, "Deck", { enumerable: true, get: function () { return __importDefault(Deck_1).default; } });
+var Dictionary_1 = require("./Dictionary");
+Object.defineProperty(exports, "Dictionary", { enumerable: true, get: function () { return __importDefault(Dictionary_1).default; } });
+var DoublyLinkedList_1 = require("./DoublyLinkedList");
+Object.defineProperty(exports, "DoublyLinkedList", { enumerable: true, get: function () { return __importDefault(DoublyLinkedList_1).default; } });
+var Graph_1 = require("./Graph");
+Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return __importDefault(Graph_1).default; } });
+var HashTable_1 = require("./HashTable");
+Object.defineProperty(exports, "HashTable", { enumerable: true, get: function () { return __importDefault(HashTable_1).default; } });
+var HashTableLinearProbing_1 = require("./HashTableLinearProbing");
+Object.defineProperty(exports, "HashTableLinearProbing", { enumerable: true, get: function () { return __importDefault(HashTableLinearProbing_1).default; } });
+var HashTableSeparateChaining_1 = require("./HashTableSeparateChaining");
+Object.defineProperty(exports, "HashTableSeparateChaining", { enumerable: true, get: function () { return __importDefault(HashTableSeparateChaining_1).default; } });
+var LinkedList_1 = require("./LinkedList");
+Object.defineProperty(exports, "LinkedList", { enumerable: true, get: function () { return __importDefault(LinkedList_1).default; } });
+var List_1 = require("./List");
+Object.defineProperty(exports, "List", { enumerable: true, get: function () { return __importDefault(List_1).default; } });
+var MaxHeap_1 = require("./MaxHeap");
+Object.defineProperty(exports, "MaxHeap", { enumerable: true, get: function () { return __importDefault(MaxHeap_1).default; } });
+var MinHeap_1 = require("./MinHeap");
+Object.defineProperty(exports, "MinHeap", { enumerable: true, get: function () { return __importDefault(MinHeap_1).default; } });
+var Queue_1 = require("./Queue");
+Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return __importDefault(Queue_1).default; } });
+var Set_1 = require("./Set");
+Object.defineProperty(exports, "Set", { enumerable: true, get: function () { return __importDefault(Set_1).default; } });
+var Stack_1 = require("./Stack");
+Object.defineProperty(exports, "Stack", { enumerable: true, get: function () { return __importDefault(Stack_1).default; } });