data-structure-typed 1.40.0-rc → 1.40.0

package/.eslintrc.js

@@ -1,12 +1,17 @@
 module.exports = {
+  "parser": "@typescript-eslint/parser",
+  "plugins": [
+    "import",
+    "@typescript-eslint"
+  ],
   "extends": [
     "plugin:@typescript-eslint/recommended",
     "prettier"
   ],
-  ignorePatterns: ["lib/", "dist/", "umd/", "coverage/", "docs/"],
+  "ignorePatterns": ["lib/", "dist/", "umd/", "coverage/", "docs/"],
   "rules": {
     "import/no-anonymous-default-export": "off",
-    "@typescript-eslint/no-unused-vars": "error",
+    "@typescript-eslint/no-unused-vars": "warn",
     "@typescript-eslint/ban-ts-comment": "off",
     "@typescript-eslint/no-explicit-any": "off",
     "@typescript-eslint/no-var-requires": "off",
@@ -39,9 +44,6 @@ module.exports = {
       }
     ]
   },
-  "plugins": [
-    "import"
-  ],
   "settings": {
     "import/parsers": {
       "@typescript-eslint/parser": [

package/.github/workflows/ci.yml

@@ -35,23 +35,5 @@ jobs:
       - name: Install dependencies
         run: npm install
 
-      - name: Print Environment Variables
-        run: env
-
-      - name: Lint
-        run: npm run lint
-
-      - name: Build and documentation
-        run: npm run build
-
-      - name: Update Individuals
-        run: npm run update:individuals
-
-      - name: Run tests
-        run: npm test
-
-      - name: Fetch Tags
-        run: git fetch --tags
-
-      - name: Changelog
-        run:  npm run changelog
+      - name: Combined ci commands together
+        run: npm run ci

package/.travis.yml

@@ -1,11 +1,10 @@
 language: node_js
 node_js:
-  - "19"
+  - "19.9.0"
 install:
-  - npm build
+  - npm install
 script:
-  - npm run lint
-  - npm run test
+  - npm run ci
 deploy:
   provider: npm
   email: zrwusa@gmail.com

package/CHANGELOG.md

@@ -8,7 +8,28 @@ All notable changes to this project will be documented in this file.
 - [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 - [`auto-changelog`](https://github.com/CookPete/auto-changelog)
 
-## [v1.35.1](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming)
+## [v1.40.0](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming)
+
+### Changes
+
+- [graph test] edge cases enriched [`#30`](https://github.com/zrwusa/data-structure-typed/pull/30)
+- [graph] Modify the data structure design of the graph to change the g… [`#29`](https://github.com/zrwusa/data-structure-typed/pull/29)
+- Optimization [`#23`](https://github.com/zrwusa/data-structure-typed/pull/23)
+- Optimization [`#20`](https://github.com/zrwusa/data-structure-typed/pull/20)
+- [binary-tree, graph] Replace all code that uses Arrays as makeshift Q… [`#18`](https://github.com/zrwusa/data-structure-typed/pull/18)
+- 1. No need for dfsIterative; integrate it directly into the dfs metho… [`#17`](https://github.com/zrwusa/data-structure-typed/pull/17)
+- [heap] fibonacci heap implemented. [test] big O estimate. [project] n… [`#15`](https://github.com/zrwusa/data-structure-typed/pull/15)
+- [rbtree] implemented, but with bugs [`#13`](https://github.com/zrwusa/data-structure-typed/pull/13)
+- [trie] renamed ambiguous methods and add comments to all methods. [`#12`](https://github.com/zrwusa/data-structure-typed/pull/12)
+- [binarytree] modified the getDepth method to adhere to the proper def… [`#11`](https://github.com/zrwusa/data-structure-typed/pull/11)
+- Trie [`#10`](https://github.com/zrwusa/data-structure-typed/pull/10)
+- [tree] getHeight returns faulty height bug fixed [`#9`](https://github.com/zrwusa/data-structure-typed/pull/9)
+- [trie] support casesensitivity. getWords bug fixed [`#8`](https://github.com/zrwusa/data-structure-typed/pull/8)
+- [binary-tree, graph] In order to optimize the design of Binary Trees,… [`#7`](https://github.com/zrwusa/data-structure-typed/pull/7)
+- [BinaryTree, Heap] In abstract classes, only retain abstract methods.… [`#6`](https://github.com/zrwusa/data-structure-typed/pull/6)
+- [heap] test [`#5`](https://github.com/zrwusa/data-structure-typed/pull/5)
+- [heap, priority queue] Heap improved. References #123: redesigned [`#4`](https://github.com/zrwusa/data-structure-typed/pull/4)
+- test [`#3`](https://github.com/zrwusa/data-structure-typed/pull/3)
 
 ## [v1.35.0](https://github.com/zrwusa/data-structure-typed/compare/v1.34.1...v1.35.0) (11 October 2023)
 

package/CONTRIBUTING.md

@@ -6,6 +6,19 @@
 - Don't forget to run `npm run lint` and `npm test` before submitting pull requests.
 - Make sure that **100%** of your code is covered by tests.
 
+**Contributing new features **
+
+- To ensure that there are no conflicts when merging the branch into the main branch, 
+- it is necessary to perform the following steps each time new development is going to be conducted on non-main branches:
+- `git pull`, 
+- `git rebase main`
+- resolve conflicts before continuing the development.
+- After new features developed
+- `git add .`
+- `git commit -m [rbtree] features` (`rbtree` needs to be replaced by the module you have modified, 
+- `features` must be replaced by the detailed description about the features you implemented)
+- `git push`
+- click the `New pull request` on Github https://github.com/zrwusa/data-structure-typed/branches
 
 **Contributing New Data Structures**
 

package/README.md

@@ -35,7 +35,7 @@ Floyd-Warshall Algorithm, Tarjan's Algorithm.
 ### npm
 
 ```bash
-npm i data-structure-typed
+npm i data-structure-typed --save
 ```
 
 ### yarn
@@ -56,7 +56,7 @@ import {
 
 ```html
 
-<script src='https://cdn.jsdelivr.net/npm/data-structure-typed/umd/bundle.min.js'></script>
+<script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>
 ```
 
 ```js
@@ -106,7 +106,7 @@ bst.getDepth(6) === 3;          // true
 
 bst.getLeftMost()?.id === 1;    // true
 
-bst.remove(6);
+bst.delete(6);
 bst.get(6);                     // null
 bst.isAVLBalanced();            // true
 bst.bfs()[0] === 11;            // true
@@ -121,7 +121,7 @@ objBST.addMany([{id: 15, keyA: 15}, {id: 1, keyA: 1}, {id: 8, keyA: 8},
   {id: 14, keyA: 14}, {id: 4, keyA: 4}, {id: 7, keyA: 7},
   {id: 10, keyA: 10}, {id: 5, keyA: 5}]);
 
-objBST.remove(11);
+objBST.delete(11);
 ```
 
 #### JS
@@ -142,7 +142,7 @@ bst.getDepth(6) === 3;  // true
 const leftMost = bst.getLeftMost();
 leftMost?.id === 1;     // true
 expect(leftMost?.id).toBe(1);
-bst.remove(6);
+bst.delete(6);
 bst.get(6);             // null
 bst.isAVLBalanced();    // true or false
 const bfsIDs = bst.bfs();
@@ -159,12 +159,12 @@ objBST.addMany([{id: 15, keyA: 15}, {id: 1, keyA: 1}, {id: 8, keyA: 8},
   {id: 14, keyA: 14}, {id: 4, keyA: 4}, {id: 7, keyA: 7},
   {id: 10, keyA: 10}, {id: 5, keyA: 5}]);
 
-objBST.remove(11);
+objBST.delete(11);
 
 const avlTree = new AVLTree();
 avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5])
 avlTree.isAVLBalanced();    // true
-avlTree.remove(10);
+avlTree.delete(10);
 avlTree.isAVLBalanced();    // true
 ```
 
@@ -178,7 +178,7 @@ import {AVLTree} from 'data-structure-typed';
 const avlTree = new AVLTree();
 avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5])
 avlTree.isAVLBalanced();    // true
-avlTree.remove(10);
+avlTree.delete(10);
 avlTree.isAVLBalanced();    // true
 ```
 
@@ -190,7 +190,7 @@ const {AVLTree} = require('data-structure-typed');
 const avlTree = new AVLTree();
 avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5])
 avlTree.isAVLBalanced();    // true
-avlTree.remove(10);
+avlTree.delete(10);
 avlTree.isAVLBalanced();    // true
 ```
 
@@ -214,7 +214,7 @@ graph.addEdge('A', 'B');
 graph.hasEdge('A', 'B');    // true
 graph.hasEdge('B', 'A');    // false
 
-graph.removeEdgeSrcToDest('A', 'B');
+graph.deleteEdgeSrcToDest('A', 'B');
 graph.hasEdge('A', 'B');    // false
 
 graph.addVertex('C');
@@ -237,7 +237,7 @@ graph.addVertex('A');
 graph.addVertex('B');
 graph.addVertex('C');
 graph.addVertex('D');
-graph.removeVertex('C');
+graph.deleteVertex('C');
 graph.addEdge('A', 'B');
 graph.addEdge('B', 'D');
 
@@ -641,6 +641,14 @@ Array.from(dijkstraResult?.seen ?? []).map(vertex => vertex.id) // ['A', 'B', 'D
 
 ## Code design
 
+### Adhere to ES6 standard naming conventions for APIs.
+
+Standardize API conventions by using 'add' and 'delete' for element manipulation methods in all data structures. 
+
+Opt for concise and clear method names, avoiding excessive length while ensuring explicit intent.
+
+### Object-oriented programming(OOP) 
+
 By strictly adhering to object-oriented design (BinaryTree -> BST -> AVLTree -> TreeMultiset), you can seamlessly
 inherit the existing data structures to implement the customized ones you need. Object-oriented design stands as the
 optimal approach to data structure design.
@@ -907,3 +915,4 @@ optimal approach to data structure design.
 </tr>
 </tbody>
 </table>
+

package/dist/cjs/data-structures/binary-tree/avl-tree.d.ts

@@ -0,0 +1,106 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import { BST, BSTNode } from './bst';
+import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BTNKey } from '../../types';
+import { BTNCallback } from '../../types';
+import { IBinaryTree } from '../../interfaces';
+export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
+    height: number;
+    constructor(key: BTNKey, value?: V);
+}
+export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
+    /**
+     * This is a constructor function for an AVL tree data structure in TypeScript.
+     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
+     * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
+     * options.
+     */
+    constructor(options?: AVLTreeOptions);
+    /**
+     * The function creates a new AVL tree node with the specified key and value.
+     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * the new node. It is used to determine the position of the node in the binary search tree.
+     * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It is of
+     * type `V`, which means it can be any value that is assignable to the `value` property of the
+     * node type `N`.
+     * @returns a new AVLTreeNode object with the specified key and value.
+     */
+    createNode(key: BTNKey, value?: V): N;
+    /**
+     * The function overrides the add method of a binary tree node and balances the tree after inserting
+     * a new node.
+     * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can accept either a
+     * `BTNKey` or a `N` (which represents a node in the binary tree) or `null`.
+     * @param [value] - The `value` parameter is the value that you want to assign to the new node that you
+     * are adding to the binary search tree.
+     * @returns The method is returning the inserted node (`N`), `null`, or `undefined`.
+     */
+    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
+    /**
+     * The function overrides the delete method of a binary tree and balances the tree after deleting a
+     * node if necessary.
+     * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
+     * `BTNKey` or a generic type `N`. It represents the property of the node that we are
+     * searching for. It can be a specific key value or any other property of the node.
+     * @param callback - The `callback` parameter is a function that takes a node as input and returns a
+     * value. This value is compared with the `identifier` parameter to determine if the node should be
+     * included in the result. The `callback` parameter has a default value of
+     * `((node: N) => node.key)`
+     * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
+     */
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C): BinaryTreeDeletedResult<N>[];
+    /**
+     * The function swaps the key, value, and height properties between two nodes in a binary tree.
+     * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+     * with the `destNode`.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+     * from the source node (`srcNode`) will be swapped to.
+     * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+     */
+    protected _swap(srcNode: N, destNode: N): N;
+    /**
+     * The function calculates the balance factor of a node in a binary tree.
+     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
+     * @returns the balance factor of a given node. The balance factor is calculated by subtracting the
+     * height of the left subtree from the height of the right subtree.
+     */
+    protected _balanceFactor(node: N): number;
+    /**
+     * The function updates the height of a node in a binary tree based on the heights of its left and
+     * right children.
+     * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
+     */
+    protected _updateHeight(node: N): void;
+    /**
+     * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
+     * to restore balance in an AVL tree after inserting a node.
+     * @param {N} node - The `node` parameter in the `_balancePath` function represents the node in the
+     * AVL tree that needs to be balanced.
+     */
+    protected _balancePath(node: N): void;
+    /**
+     * The function `_balanceLL` performs a left-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
+     */
+    protected _balanceLL(A: N): void;
+    /**
+     * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
+     */
+    protected _balanceLR(A: N): void;
+    /**
+     * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
+     */
+    protected _balanceRR(A: N): void;
+    /**
+     * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
+     * @param {N} A - A is a node in a binary tree.
+     */
+    protected _balanceRL(A: N): void;
+}