data-structure-typed 1.17.0 → 1.17.3

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -101,7 +101,7 @@ export declare class DoublyLinkedList<T> {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insert(index: number, val: T): boolean;
+    insertAt(index: number, val: T): boolean;
     /**
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -110,13 +110,8 @@ export declare class DoublyLinkedList<T> {
      * bounds.
      */
     deleteAt(index: number): T | null;
-    /**
-     * The `delete` function removes a node with a specific value from a doubly linked list.
-     * @param {T} val - The `val` parameter represents the value that you want to delete from the linked list.
-     * @returns The `delete` method returns a boolean value. It returns `true` if the value `val` is found and deleted from
-     * the linked list, and `false` if the value is not found in the linked list.
-     */
-    delete(val: T): boolean;
+    delete(valOrNode: T): boolean;
+    delete(valOrNode: DoublyLinkedListNode<T>): boolean;
     /**
      * The `toArray` function converts a linked list into an array.
      * @returns The `toArray()` method is returning an array of type `T[]`.
@@ -195,22 +190,8 @@ export declare class DoublyLinkedList<T> {
      * elements in the linked list.
      */
     reduce<U>(callback: (accumulator: U, val: T) => U, initialValue: U): U;
-    /**
-     * The function inserts a new value after an existing value in a doubly linked list.
-     * @param {T} existingValue - The existing value is the value of the node after which we want to insert the new value.
-     * @param {T} newValue - The `newValue` parameter represents the value of the new node that you want to insert after
-     * the existing node.
-     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
-     * existing value is not found in the linked list.
-     */
-    insertAfter(existingValue: T, newValue: T): boolean;
-    /**
-     * The `insertBefore` function inserts a new value before an existing value in a doubly linked list.
-     * @param {T} existingValue - The existing value is the value of the node that you want to insert the new value before.
-     * @param {T} newValue - The `newValue` parameter represents the value of the new node that you want to insert before
-     * the existing node.
-     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
-     * existing value is not found in the linked list.
-     */
-    insertBefore(existingValue: T, newValue: T): boolean;
+    insertAfter(existingValueOrNode: T, newValue: T): boolean;
+    insertAfter(existingValueOrNode: DoublyLinkedListNode<T>, newValue: T): boolean;
+    insertBefore(existingValueOrNode: T, newValue: T): boolean;
+    insertBefore(existingValueOrNode: DoublyLinkedListNode<T>, newValue: T): boolean;
 }

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -279,7 +279,7 @@ var DoublyLinkedList = /** @class */ (function () {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    DoublyLinkedList.prototype.insert = function (index, val) {
+    DoublyLinkedList.prototype.insertAt = function (index, val) {
         if (index < 0 || index > this.length)
             return false;
         if (index === 0) {
@@ -323,31 +323,35 @@ var DoublyLinkedList = /** @class */ (function () {
         return removedNode.val;
     };
     /**
-     * The `delete` function removes a node with a specific value from a doubly linked list.
-     * @param {T} val - The `val` parameter represents the value that you want to delete from the linked list.
-     * @returns The `delete` method returns a boolean value. It returns `true` if the value `val` is found and deleted from
-     * the linked list, and `false` if the value is not found in the linked list.
+     * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
+     * @param {T | DoublyLinkedListNode<T>} valOrNode - The `valOrNode` parameter can accept either a value of type `T` or
+     * a `DoublyLinkedListNode<T>` object.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the value or node was successfully
+     * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
      */
-    DoublyLinkedList.prototype.delete = function (val) {
-        var current = this.head;
-        while (current) {
-            if (current.val === val) {
-                if (current === this.head) {
-                    this.shift();
-                }
-                else if (current === this.tail) {
-                    this.pop();
-                }
-                else {
-                    var prevNode = current.prev;
-                    var nextNode = current.next;
-                    prevNode.next = nextNode;
-                    nextNode.prev = prevNode;
-                    this.length--;
-                }
-                return true;
+    DoublyLinkedList.prototype.delete = function (valOrNode) {
+        var node;
+        if (valOrNode instanceof (DoublyLinkedListNode)) {
+            node = valOrNode;
+        }
+        else {
+            node = this.findNode(valOrNode);
+        }
+        if (node) {
+            if (node === this.head) {
+                this.shift();
             }
-            current = current.next;
+            else if (node === this.tail) {
+                this.pop();
+            }
+            else {
+                var prevNode = node.prev;
+                var nextNode = node.next;
+                prevNode.next = nextNode;
+                nextNode.prev = prevNode;
+                this.length--;
+            }
+            return true;
         }
         return false;
     };
@@ -522,15 +526,22 @@ var DoublyLinkedList = /** @class */ (function () {
         return accumulator;
     };
     /**
-     * The function inserts a new value after an existing value in a doubly linked list.
-     * @param {T} existingValue - The existing value is the value of the node after which we want to insert the new value.
-     * @param {T} newValue - The `newValue` parameter represents the value of the new node that you want to insert after
-     * the existing node.
-     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
-     * existing value is not found in the linked list.
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+     * @param {T | DoublyLinkedListNode<T>} existingValueOrNode - The existing value or node in the doubly linked list
+     * after which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {T} newValue - The value that you want to insert into the doubly linked list.
+     * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
+     * existing value or node is not found in the doubly linked list.
      */
-    DoublyLinkedList.prototype.insertAfter = function (existingValue, newValue) {
-        var existingNode = this.findNode(existingValue);
+    DoublyLinkedList.prototype.insertAfter = function (existingValueOrNode, newValue) {
+        var existingNode;
+        if (existingValueOrNode instanceof (DoublyLinkedListNode)) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.findNode(existingValueOrNode);
+        }
         if (existingNode) {
             var newNode = new DoublyLinkedListNode(newValue);
             newNode.next = existingNode.next;
@@ -548,15 +559,23 @@ var DoublyLinkedList = /** @class */ (function () {
         return false;
     };
     /**
-     * The `insertBefore` function inserts a new value before an existing value in a doubly linked list.
-     * @param {T} existingValue - The existing value is the value of the node that you want to insert the new value before.
-     * @param {T} newValue - The `newValue` parameter represents the value of the new node that you want to insert before
-     * the existing node.
-     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
-     * existing value is not found in the linked list.
+     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * @param {T | DoublyLinkedListNode<T>} existingValueOrNode - The existing value or node in the doubly linked list
+     * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+     * itself.
+     * @param {T} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+     * list.
+     * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+     * insertion fails.
      */
-    DoublyLinkedList.prototype.insertBefore = function (existingValue, newValue) {
-        var existingNode = this.findNode(existingValue);
+    DoublyLinkedList.prototype.insertBefore = function (existingValueOrNode, newValue) {
+        var existingNode;
+        if (existingValueOrNode instanceof (DoublyLinkedListNode)) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.findNode(existingValueOrNode);
+        }
         if (existingNode) {
             var newNode = new DoublyLinkedListNode(newValue);
             newNode.prev = existingNode.prev;

package/dist/data-structures/linked-list/index.d.ts

@@ -1,2 +1,3 @@
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
+export * from './skip-linked-list';

package/dist/data-structures/linked-list/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./singly-linked-list"), exports);
 __exportStar(require("./doubly-linked-list"), exports);
+__exportStar(require("./skip-linked-list"), exports);

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -89,17 +89,10 @@ export declare class SinglyLinkedList<T> {
      * bounds.
      */
     deleteAt(index: number): T | null;
+    delete(valueOrNode: T): boolean;
+    delete(valueOrNode: SinglyLinkedListNode<T>): boolean;
     /**
-     * The `delete` function removes a specified value from a linked list and returns true if the value was found and
-     * removed, otherwise it returns false.
-     * @param {T} value - The value parameter represents the value of the node that needs to be deleted from the linked
-     * list.
-     * @returns The `delete` method returns a boolean value. It returns `true` if the value was successfully deleted from
-     * the linked list, and `false` if the value was not found in the linked list.
-     */
-    delete(value: T): boolean;
-    /**
-     * The `insert` function inserts a value at a specified index in a singly linked list.
+     * The `insertAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
      * @param {T} val - The `val` parameter represents the value that you want to insert into the linked list at the
@@ -107,7 +100,7 @@ export declare class SinglyLinkedList<T> {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insert(index: number, val: T): boolean;
+    insertAt(index: number, val: T): boolean;
     /**
      * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
      * whether it is empty or not.
@@ -151,25 +144,10 @@ export declare class SinglyLinkedList<T> {
      * the specified value is found, the function returns `null`.
      */
     findNode(value: T): SinglyLinkedListNode<T> | null;
-    /**
-     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
-     * @param {T} existingValue - The existing value is the value that already exists in the linked list and before which
-     * we want to insert a new value.
-     * @param {T} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The `insertBefore` function returns a boolean value. It returns `true` if the `newValue` is successfully
-     * inserted before the first occurrence of `existingValue` in the linked list. It returns `false` if the
-     * `existingValue` is not found in the linked list.
-     */
     insertBefore(existingValue: T, newValue: T): boolean;
-    /**
-     * The function inserts a new value after an existing value in a singly linked list.
-     * @param {T} existingValue - The existing value is the value of the node after which we want to insert the new value.
-     * @param {T} newValue - The `newValue` parameter represents the value that you want to insert into the linked list
-     * after the node with the `existingValue`.
-     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
-     * existing value is not found in the linked list.
-     */
-    insertAfter(existingValue: T, newValue: T): boolean;
+    insertBefore(existingValue: SinglyLinkedListNode<T>, newValue: T): boolean;
+    insertAfter(existingValueOrNode: T, newValue: T): boolean;
+    insertAfter(existingValueOrNode: SinglyLinkedListNode<T>, newValue: T): boolean;
     /**
      * The function counts the number of occurrences of a given value in a linked list.
      * @param {T} value - The value parameter is the value that you want to count the occurrences of in the linked list.

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -257,16 +257,21 @@ var SinglyLinkedList = /** @class */ (function () {
         return removedNode.val;
     };
     /**
-     * The `delete` function removes a specified value from a linked list and returns true if the value was found and
-     * removed, otherwise it returns false.
-     * @param {T} value - The value parameter represents the value of the node that needs to be deleted from the linked
-     * list.
-     * @returns The `delete` method returns a boolean value. It returns `true` if the value was successfully deleted from
-     * the linked list, and `false` if the value was not found in the linked list.
+     * The delete function removes a node with a specific value from a singly linked list.
+     * @param {T | SinglyLinkedListNode<T>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `T`
+     * or a `SinglyLinkedListNode<T>` object.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
+     * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
      */
-    SinglyLinkedList.prototype.delete = function (value) {
-        var current = this.head;
-        var prev = null;
+    SinglyLinkedList.prototype.delete = function (valueOrNode) {
+        var value;
+        if (valueOrNode instanceof (SinglyLinkedListNode)) {
+            value = valueOrNode.val;
+        }
+        else {
+            value = valueOrNode;
+        }
+        var current = this.head, prev = null;
         while (current) {
             if (current.val === value) {
                 if (prev === null) {
@@ -290,7 +295,7 @@ var SinglyLinkedList = /** @class */ (function () {
         return false;
     };
     /**
-     * The `insert` function inserts a value at a specified index in a singly linked list.
+     * The `insertAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
      * @param {T} val - The `val` parameter represents the value that you want to insert into the linked list at the
@@ -298,7 +303,7 @@ var SinglyLinkedList = /** @class */ (function () {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    SinglyLinkedList.prototype.insert = function (index, val) {
+    SinglyLinkedList.prototype.insertAt = function (index, val) {
         if (index < 0 || index > this.length)
             return false;
         if (index === 0) {
@@ -418,16 +423,21 @@ var SinglyLinkedList = /** @class */ (function () {
     };
     /**
      * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
-     * @param {T} existingValue - The existing value is the value that already exists in the linked list and before which
-     * we want to insert a new value.
+     * @param {T | SinglyLinkedListNode<T>} existingValueOrNode - The existing value or node that you want to insert the
+     * new value before. It can be either the value itself or a node containing the value in the linked list.
      * @param {T} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The `insertBefore` function returns a boolean value. It returns `true` if the `newValue` is successfully
-     * inserted before the first occurrence of `existingValue` in the linked list. It returns `false` if the
-     * `existingValue` is not found in the linked list.
+     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * inserted before the existing value, and `false` otherwise.
      */
-    SinglyLinkedList.prototype.insertBefore = function (existingValue, newValue) {
-        if (!this.head) {
+    SinglyLinkedList.prototype.insertBefore = function (existingValueOrNode, newValue) {
+        if (!this.head)
             return false;
+        var existingValue;
+        if (existingValueOrNode instanceof (SinglyLinkedListNode)) {
+            existingValue = existingValueOrNode.val;
+        }
+        else {
+            existingValue = existingValueOrNode;
         }
         if (this.head.val === existingValue) {
             this.unshift(newValue);
@@ -447,15 +457,21 @@ var SinglyLinkedList = /** @class */ (function () {
         return false;
     };
     /**
-     * The function inserts a new value after an existing value in a singly linked list.
-     * @param {T} existingValue - The existing value is the value of the node after which we want to insert the new value.
-     * @param {T} newValue - The `newValue` parameter represents the value that you want to insert into the linked list
-     * after the node with the `existingValue`.
-     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
-     * existing value is not found in the linked list.
+     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * @param {T | SinglyLinkedListNode<T>} existingValueOrNode - The existing value or node in the linked list after which
+     * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
+     * @param {T} newValue - The value that you want to insert into the linked list after the existing value or node.
+     * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
+     * existing value or node, and false if the existing value or node was not found in the linked list.
      */
-    SinglyLinkedList.prototype.insertAfter = function (existingValue, newValue) {
-        var existingNode = this.findNode(existingValue);
+    SinglyLinkedList.prototype.insertAfter = function (existingValueOrNode, newValue) {
+        var existingNode;
+        if (existingValueOrNode instanceof SinglyLinkedListNode) {
+            existingNode = existingValueOrNode;
+        }
+        else {
+            existingNode = this.findNode(existingValueOrNode);
+        }
         if (existingNode) {
             var newNode = new SinglyLinkedListNode(newValue);
             newNode.next = existingNode.next;

package/dist/data-structures/linked-list/skip-linked-list.d.ts

@@ -1 +1,2 @@
-export {};
+export declare class SkipLinkedList {
+}

package/dist/data-structures/linked-list/skip-linked-list.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipLinkedList = void 0;
+var SkipLinkedList = /** @class */ (function () {
+    function SkipLinkedList() {
+    }
+    return SkipLinkedList;
+}());
+exports.SkipLinkedList = SkipLinkedList;

package/dist/data-structures/matrix/vector2d.js

@@ -221,14 +221,14 @@ var Vector2D = /** @class */ (function () {
     //  * Transform vectors based on the current tranformation matrices: translation, rotation and scale
     //  * @param vectors The vectors to transform
     //  */
-    // public static transform(vector: Vector2D, transformation: Matrix2D): Vector2D {
+    // static transform(vector: Vector2D, transformation: Matrix2D): Vector2D {
     //     return Matrix2D.multiplyByVector(transformation, vector)
     // }
     // /**
     //  * Transform vectors based on the current tranformation matrices: translation, rotation and scale
     //  * @param vectors The vectors to transform
     //  */
-    // public static transformList(vectors: Vector2D[], transformation: Matrix2D): Vector2D[] {
+    // static transformList(vectors: Vector2D[], transformation: Matrix2D): Vector2D[] {
     //     return vectors.map(vector => Matrix2D.multiplyByVector(transformation, vector))
     // }
     /**