data-structure-typed 0.9.16 → 1.3.0

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

@@ -1,354 +1,156 @@
-import type { TMapFunction, TTestFunction } from '../types';
 /**
- * The class which represents one link or node in a linked list
- * ```ts
- * const node = new SinglyLinkedListNode(1, null, null, null);
- * ```
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
-export declare class SinglyLinkedListNode<NodeData = any> {
-    /** Data stored on the node */
-    val: NodeData;
-    /** The previous node in the list */
-    prev: SinglyLinkedListNode<NodeData> | null;
-    /** The next link in the list */
-    next: SinglyLinkedListNode<NodeData> | null;
-    /** The list this node belongs to */
-    list: SinglyLinkedList<NodeData> | null;
-    constructor(
-    /** Data stored on the node */
-    val: NodeData, 
-    /** The previous node in the list */
-    prev: SinglyLinkedListNode<NodeData> | null, 
-    /** The next link in the list */
-    next: SinglyLinkedListNode<NodeData> | null, 
-    /** The list this node belongs to */
-    list: SinglyLinkedList<NodeData> | null);
-    /**
-     * Alias to .val
-     * ```ts
-     * new LinkedList(1, 2, 3).head.value; // 1
-     * ```
-     */
-    get value(): NodeData;
-    /**
-     * Get the index of this node
-     * ```ts
-     * new LinkedList(1, 2, 3).head.index; // 0
-     * ```
-     */
-    get index(): number | undefined;
-    /**
-     * Insert a new node before this one
-     * ```ts
-     * new LinkedList(2, 3).head.insertBefore(1); // 1 <=> 2 <=> 3
-     * ```
-     * @param val Data to save in the node
-     */
-    insertBefore(val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Insert new val after this node
-     * ```ts
-     * new LinkedList(1, 2).tail.insertAfter(3); // 1 <=> 2 <=> 3
-     * ```
-     * @param val Data to be saved in the node
-     */
-    insertAfter(val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Remove this node
-     * ```ts
-     * new LinkedList(1, 2, 3, 4).tail.remove(); // 1 <=> 2 <=> 3
-     * ```
-     */
-    remove(): SinglyLinkedListNode<NodeData>;
+export declare class SinglyLinkedListNode<T = number> {
+    /**
+     * The constructor function initializes an instance of a class with a given value and sets the next property to null.
+     * @param {T} val - The "val" parameter is of type T, which means it can be any data type. It represents the value that
+     * will be stored in the node of a linked list.
+     */
+    constructor(val: T);
+    private _val;
+    get val(): T;
+    set val(value: T);
+    private _next;
+    get next(): SinglyLinkedListNode<T> | null;
+    set next(value: SinglyLinkedListNode<T> | null);
 }
-/**
- * A doubly linked list
- * ```ts
- * const list = new LinkedList(1, 2, 3);
- * const listFromArray = LinkedList.from([1, 2, 3]);
- * ```
- */
-export declare class SinglyLinkedList<NodeData = any> {
-    /** The head of the list, the first node */
-    head: SinglyLinkedListNode<NodeData> | null;
-    /** The tail of the list, the last node */
-    tail: SinglyLinkedListNode<NodeData> | null;
-    /** Internal size reference */
-    private size;
-    constructor(...args: NodeData[]);
-    /**
-     * The length of the list
-     */
+export declare class SinglyLinkedList<T = any> {
+    /**
+     * The constructor initializes the linked list with an empty head, tail, and length.
+     */
+    constructor();
+    private _head;
+    get head(): SinglyLinkedListNode<T> | null;
+    set head(value: SinglyLinkedListNode<T> | null);
+    private _tail;
+    get tail(): SinglyLinkedListNode<T> | null;
+    set tail(value: SinglyLinkedListNode<T> | null);
+    private _length;
     get length(): number;
     /**
-     * Convert any iterable to a new linked list
-     * ```javascript
-     * const array = [1, 2, 3];
-     * const list = LinkedList.from(array);
-     * ```
-     * @param iterable Any iterable datatype like Array or Map
-     */
-    static from<T>(iterable: Iterable<T>): SinglyLinkedList<T>;
-    /**
-     * Get the node val at a specified index, zero based
-     * ```ts
-     * new LinkedList(1, 2, 3).get(0); // 1
-     * ```
-     * @param index to retrieve val at
-     */
-    get(index: number): NodeData | undefined;
-    /**
-     * Get the node at index, zero based
-     * ```ts
-     * new LinkedList(1, 2, 3).getNode(0);
-     * // { prev: null, val: 1, next: SinglyLinkedListNode }
-     * ```
-     */
-    getNode(index: number): SinglyLinkedListNode<NodeData> | undefined;
-    /**
-     * Return the first node and its index in the list that
-     * satisfies the testing function
-     * ```ts
-     * new LinkedList(1, 2, 3).findNodeIndex(val => val === 1);
-     * // { node: SinglyLinkedListNode, index: 0 }
-     * ```
-     * @param f A function to be applied to the val of each node
-     */
-    findNodeIndex(f: TTestFunction<NodeData>): ({
-        node: SinglyLinkedListNode<NodeData>;
-        index: number;
-    }) | undefined;
-    /**
-     * Returns the first node in the list that
-     * satisfies the provided testing function. Otherwise undefined is returned.
-     * ```ts
-     * new LinkedList(1, 2, 3).findNode(val => val === 1);
-     * // { prev: null, val: 1, next: SinglyLinkedListNode }
-     * ```
-     * @param f Function to test val against
-     */
-    findNode(f: TTestFunction<NodeData>): SinglyLinkedListNode<NodeData> | undefined;
-    /**
-     * Returns the value of the first element in the list that
-     * satisfies the provided testing function. Otherwise undefined is returned.
-     * ```ts
-     * new LinkedList(1, 2, 3).find(val => val === 1); // 1
-     * ```
-     * @param f Function to test val against
-     */
-    find(f: TTestFunction<NodeData>): NodeData | undefined;
-    /**
-     * Returns the index of the first node in the list that
-     * satisfies the provided testing function. Ohterwise -1 is returned.
-     * ```ts
-     * new LinkedList(1, 2, 3).findIndex(val => val === 3); // 2
-     * ```
-     * @param f Function to test val against
-     */
-    findIndex(f: TTestFunction<NodeData>): number;
-    /**
-     * Append one or any number of nodes to the end of the list.
-     * This modifies the list in place and returns the list itself
-     * to make this method chainable.
-     * ```ts
-     * new LinkedList(1).append(2).append(3, 4); // 1 <=> 2 <=> 3 <=> 4
-     * ```
-     * @param args Data to be stored in the node, takes any number of arguments
-     */
-    append(...args: NodeData[]): SinglyLinkedList<NodeData>;
-    /**
-     * Synonym for append
-     * ```ts
-     * new LinkedList(1).push(2).push(3, 4); // 1 <=> 2 <=> 3 <=> 4
-     * ```
-     * @param args Data to be stored, takes any number of arguments
-     */
-    push(...args: NodeData[]): number;
-    /**
-     * Prepend any number of val arguments to the list. The
-     * argument list is prepended as a block to reduce confusion:
-     * ```javascript
-     * new LinkedList(3, 4).prepend(0, 1, 2); // [0, 1, 2, 3, 4]
-     * ```
-     * @param args Data to be stored in the node, accepts any number of arguments
-     */
-    prepend(...args: NodeData[]): SinglyLinkedList<NodeData>;
-    /**
-     * Insert a new node at a given index position. If index is
-     * out of bounds, the node is appended, if index is negative
-     * or 0, it will be prepended.
-     * ```ts
-     * new LinkedList(1, 3).insertAt(1, 2); // 1 <=> 2 <=> 3
-     * ```
-     * @param index The index to insert the new node at
-     * @param val Data to be stored on the new node
-     */
-    insertAt(index: number, val: NodeData): SinglyLinkedList<NodeData>;
-    /**
-     * Remove the specified node from the list and return the removed
-     * node afterwards.
-     * ```ts
-     * const list = new LinkedList(1, 2, 3);
-     * list.removeNode(list.tail); // { prev: null, val: 3, next: null, list: null }
-     * ```
-     * @param node The node to be removed
-     */
-    removeNode(node: SinglyLinkedListNode<NodeData>): SinglyLinkedListNode<NodeData>;
-    /**
-     * Remove the node at the specified index
-     * ```ts
-     * new LinkedList(1, 2, 3).removeAt(2); // { prev: null, val: 3, next: null, list: null }
-     * ```
-     * @param index Index at which to remove
+     * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
+     * array.
+     * @param {T[]} data - The `data` parameter is an array of elements of type `T`.
+     * @returns The `fromArray` function returns a `SinglyLinkedList` object.
      */
-    removeAt(index: number): SinglyLinkedListNode<NodeData> | undefined;
+    static fromArray<T>(data: T[]): SinglyLinkedList<T>;
+    getLength(): number;
     /**
-     * Insert a new node before the reference node
-     * ```ts
-     * const list = new LinkedList(1, 3);
-     * list.insertBefore(list.tail, 2); // 1 <=> 2 <=> 3
-     * ```
-     * @param referenceNode The node reference
-     * @param val Data to save in the node
+     * The `push` function adds a new node with the given data to the end of a singly linked list.
+     * @param {T} data - The "data" parameter represents the value that you want to add to the linked list. It can be of
+     * any type (T) as specified in the generic type declaration of the class or function.
      */
-    insertBefore(referenceNode: SinglyLinkedListNode<NodeData>, val: NodeData): SinglyLinkedList<NodeData>;
+    push(data: T): void;
     /**
-     * Sorts the linked list using the provided compare function
-     * @param compare A function used to compare the val of two nodes. It should return
-     *                a boolean. True will insert a before b, false will insert b before a.
-     *                (a, b) => a < b or (1, 2) => 1 < 2 === true, 2 will be inserted after 1,
-     *                the sort order will be ascending.
+     * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * pointers accordingly.
+     * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
+     * the linked list is empty, it returns `null`.
      */
-    sort(compare: (a: NodeData, b: NodeData) => boolean): SinglyLinkedList<NodeData>;
+    pop(): T | undefined;
     /**
-     * Insert a new node after this one
-     * ```ts
-     * const list = new LinkedList(2, 3);
-     * list.insertAfter(list.head, 1); // 1 <=> 2 <=> 3
-     * ```
-     * @param referenceNode The reference node
-     * @param val Data to be saved in the node
+     * The `shift()` function removes and returns the value of the first node in a linked list.
+     * @returns The value of the node that is being removed from the beginning of the linked list.
      */
-    insertAfter(referenceNode: SinglyLinkedListNode<NodeData>, val: NodeData): SinglyLinkedList<NodeData>;
+    shift(): T | undefined;
     /**
-     * Remove the first node from the list and return the val of the removed node
-     * or undefined
-     * ```ts
-     * new LinkedList(1, 2, 3).shift(); // 1
-     * ```
+     * The unshift function adds a new node with the given value to the beginning of a singly linked list.
+     * @param {T} val - The parameter "val" represents the value of the new node that will be added to the beginning of the
+     * linked list.
      */
-    shift(): NodeData | undefined;
+    unshift(val: T): void;
     /**
-     * Remove the last node from the list and return the val of the removed node
-     * or undefined if the list was empty
-     * ```ts
-     * new LinkedList(1, 2, 3).pop(); // 3
-     * ```
+     * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
+     * @param {number} index - The index parameter is a number that represents the position of the element we want to
+     * retrieve from the list.
+     * @returns The method `getAt(index: number): T | null` returns the value at the specified index in the linked list, or
+     * `null` if the index is out of bounds.
      */
-    pop(): NodeData | undefined;
+    getAt(index: number): T | null;
     /**
-     * Merge the current list with another. Both lists will be
-     * equal after merging.
-     * ```ts
-     * const list = new LinkedList(1, 2);
-     * const otherList = new LinkedList(3);
-     * list.merge(otherList);
-     * (list === otherList); // true
-     * ```
-     * @param list The list to be merged
+     * The function `getNodeAt` returns the node at a given index in a singly linked list.
+     * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
+     * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
+     * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<T>` object if the node at the
+     * specified index exists, or `null` if the index is out of bounds.
      */
-    merge(list: SinglyLinkedList<NodeData>): void;
+    getNodeAt(index: number): SinglyLinkedListNode<T> | null;
     /**
-     * Removes all nodes from a list
-     *
-     * ```ts
-     * list.clear();
-     * ```
+     * 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
+     * data structure. It is of type number.
+     * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
+     * bounds.
      */
-    clear(): this;
+    deleteAt(index: number): T | undefined;
+    delete(valueOrNode: T): boolean;
+    delete(valueOrNode: SinglyLinkedListNode<T>): boolean;
     /**
-     * The slice() method returns a shallow copy of a
-     * portion of a list into a new list object selected
-     * from start to end (end not included).
-     * The original list will not be modified.
-     * ```ts
-     * const list = new LinkedList(1, 2, 3, 4, 5);
-     * const newList = list.slice(0, 3); // 1 <=> 2 <=> 3
-     * ```
-     * @param start Start index
-     * @param end End index, optional
+     * 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
+     * specified index.
+     * @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.
      */
-    slice(start: number, end?: number): SinglyLinkedList<NodeData | {}>;
+    insertAt(index: number, val: T): boolean;
     /**
-     * The reverse() function reverses the list in place and returns the list
-     * itself.
-     * ```ts
-     * new LinkedList(1, 2, 3).reverse(); // 3 <=> 2 <=> 1
-     * ```
+     * 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.
+     * @returns A boolean value indicating whether the length of the object is equal to 0.
      */
-    reverse(): SinglyLinkedList<NodeData>;
+    isEmpty(): boolean;
     /**
-     * The forEach() method executes a provided function once for each list node.
-     * ```ts
-     * new LinkedList(1, 2, 3).forEach(val => log(val)); // 1 2 3
-     * ```
-     * @param f Function to execute for each element, taking up to three arguments.
-     * @param reverse Indicates if the list should be walked in reverse order, default is false
+     * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
      */
-    forEach(f: TMapFunction<NodeData>, reverse?: boolean): void;
+    clear(): void;
     /**
-     * The map() method creates a new list with the results of
-     * calling a provided function on every node in the calling list.
-     * ```ts
-     * new LinkedList(1, 2, 3).map(val => val + 10); // 11 <=> 12 <=> 13
-     * ```
-     * @param f Function that produces an node of the new list, taking up to three arguments
-     * @param reverse Indicates if the list should be mapped in reverse order, default is false
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `T[]`.
      */
-    map(f: TMapFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
+    toArray(): T[];
     /**
-     * The filter() method creates a new list with all nodes
-     * that pass the test implemented by the provided function.
-     * ```ts
-     * new LinkedList(1, 2, 3, 4, 5).filter(val => val < 4); // 1 <=> 2 <=> 3
-     * ```
-     * @param f Function to test each node val in the list. Return true to keep the node
-     * @param reverse Indicates if the list should be filtered in reverse order, default is false
+     * The `reverse` function reverses the order of the nodes in a singly linked list.
+     * @returns The reverse() method does not return anything. It has a return type of void.
      */
-    filter(f: TTestFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
+    reverse(): void;
     /**
-     * Reduce over each node in the list
-     * ```ts
-     * new LinkedList(1, 2, 3).reduce(n => n += 1, 0); // 3
-     * ```
-     * @param f A reducer function
-     * @param start An initial value
-     * @returns The final state of the accumulator
+     * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
+     * @param callback - A function that takes a value of type T as its parameter and returns a boolean value. This
+     * function is used to determine whether a particular value in the linked list satisfies a certain condition.
+     * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
+     * the callback function. If no element satisfies the condition, it returns `null`.
      */
-    reduce(f: (accumulator: any, currentNode: NodeData, index: number, list: SinglyLinkedList<NodeData>) => any, start?: any, reverse?: boolean): any;
+    find(callback: (val: T) => boolean): T | null;
     /**
-     * Convert the linked list to an array
-     * ```ts
-     * new LinkedList(1, 2, 3).toArray(); // [1, 2, 3]
-     * ```
+     * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
+     * @param {T} value - The value parameter is the value that you want to find the index of in the linked list.
+     * @returns The method is returning the index of the first occurrence of the specified value in the linked list. If the
+     * value is not found, it returns -1.
      */
-    toArray(): NodeData[];
+    indexOf(value: T): number;
     /**
-     * Convert a linked list to string
-     * ```ts
-     * new LinkedList('one', 'two', 'three').toString(' <=> ') === 'one <=> two <=> three';
-     * ```
-     * @param separator Optional string to be placed in between val nodes, default is one space
+     * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
+     * null.
+     * @param {T} value - The value parameter is the value that we want to search for in the linked list.
+     * @returns a `SinglyLinkedListNode<T>` if a node with the specified value is found in the linked list. If no node with
+     * the specified value is found, the function returns `null`.
      */
-    toString(separator?: string): string;
+    findNode(value: T): SinglyLinkedListNode<T> | null;
+    insertBefore(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 iterator implementation
-     * ```ts
-     * const list = new LinkedList(1, 2, 3);
-     * for (const val of list) { log(val); } // 1 2 3
-     * ```
+     * 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.
+     * @returns The count of occurrences of the given value in the linked list.
      */
-    [Symbol.iterator](): IterableIterator<NodeData>;
-    /** Private helper function to reduce duplication of pop() and shift() methods */
-    private removeFromAnyEnd;
+    countOccurrences(value: T): number;
 }