x/data-structure-typed
1
0
Fork 0
mirror of https://github.com/zrwusa/data-structure-typed.git synced 2024-11-23 04:44:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: Remove the meaningless Tree data structure.

Browse source 
refactor: Adjust the logic of isRealNode for a slight performance improvement.
docs: table fixed
This commit is contained in:
Revone 2024-01-16 11:26:43 +08:00
parent e2f554fb5c
commit 25e9f36577
8 changed files with 6 additions and 159 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CHANGELOG.md
View file

@ -8,7 +8,7 @@ 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.51.2](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming)
## [v1.51.3](https://github.com/zrwusa/data-structure-typed/compare/v1.35.0...main) (upcoming)
### Changes

3
README.md
View file

@ -291,6 +291,7 @@ We provide data structures that are not available in JS/TS
<td><img src="https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/assets/tick.svg" alt=""></td>
<td><img src="https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/assets/tick.svg" alt=""></td>
<td><a href="https://data-structure-typed-docs.vercel.app/classes/HashMap.html"><span>View</span></a></td>
<td><a href="https://www.npmjs.com/package/hashmap-typed"><span></span></a></td>
</tr>
<tr>
<td>Linked List</td>
@ -325,12 +326,14 @@ We provide data structures that are not available in JS/TS
<td><img src="https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/assets/tick.svg" alt=""></td>
<td></td>
<td><a href="https://data-structure-typed-docs.vercel.app/classes/SegmentTree.html"><span>View</span></a></td>
<td><a href="https://www.npmjs.com/package/segment-tree-typed"><span></span></a></td>
</tr>
<tr>
<td>Binary Indexed Tree</td>
<td><img src="https://raw.githubusercontent.com/zrwusa/assets/master/images/data-structure-typed/assets/tick.svg" alt=""></td>
<td></td>
<td><a href="https://data-structure-typed-docs.vercel.app/classes/BinaryIndexedTree.html"><span>View</span></a></td>
<td><a href="https://www.npmjs.com/package/binary-indexed-tree-typed"><span></span></a></td>
</tr>
</tbody>
</table>

4
src/data-structures/binary-tree/binary-tree.ts
View file

@ -316,8 +316,8 @@ export class BinaryTree<
* @returns a boolean value.
*/
isRealNode(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE {
if (!this.isNode(node)) return false;
return node !== this.NIL;
if (node === this.NIL || node === null || node === undefined) return false;
return this.isNode(node);
}
/**

1
src/data-structures/index.ts
View file

@ -4,7 +4,6 @@ export * from './stack';
export * from './queue';
export * from './graph';
export * from './binary-tree';
export * from './tree';
export * from './heap';
export * from './priority-queue';
export * from './matrix';

1
src/data-structures/tree/index.ts
View file

@ -1 +0,0 @@
export * from './tree';

115
src/data-structures/tree/tree.ts
View file

@ -1,115 +0,0 @@
export class TreeNode<V = any> {
/**
* The constructor function initializes a TreeNode object with a key, optional value, and optional
* children.
* @param {string} key - A string representing the key of the tree node.
* @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
* value associated with the node. If no value is provided, it defaults to `undefined`.
* @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
* objects. It represents the child nodes of the current node. If no children are provided, the
* default value is an empty array.
*/
constructor(key: string, value?: V, children?: TreeNode<V>[]) {
this._key = key;
this._value = value || undefined;
this._children = children || [];
}
protected _key: string;
/**
* The function returns the value of the protected variable _key.
* @returns The value of the `_key` property, which is a string.
*/
get key(): string {
return this._key;
}
/**
* The above function sets the value of a protected variable called "key".
* @param {string} value - The value parameter is a string that represents the value to be assigned
* to the key.
*/
set key(value: string) {
this._key = value;
}
protected _value?: V | undefined;
/**
* The function returns the value stored in a variable, or undefined if the variable is empty.
* @returns The value of the variable `_value` is being returned.
*/
get value(): V | undefined {
return this._value;
}
/**
* The function sets the value of a variable.
* @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
* can accept a value of type "V" or it can be undefined.
*/
set value(value: V | undefined) {
this._value = value;
}
protected _children?: TreeNode<V>[] | undefined;
/**
* The function returns an array of TreeNode objects or undefined.
* @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
* which means it can either be an array of `TreeNode<V>` objects or `undefined`.
*/
get children(): TreeNode<V>[] | undefined {
return this._children;
}
/**
* The function sets the value of the children property of a TreeNode object.
* @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
* undefined. This means that it can accept an array of TreeNode objects or undefined.
*/
set children(value: TreeNode<V>[] | undefined) {
this._children = value;
}
/**
* The function `addChildren` adds one or more child nodes to the current node.
* @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
* `TreeNode<V>` object or an array of `TreeNode<V>` objects.
*/
addChildren(children: TreeNode<V> | TreeNode<V>[]) {
if (!this._children) {
this._children = [];
}
if (children instanceof TreeNode) {
this._children.push(children);
} else {
this._children = this._children.concat(children);
}
}
/**
* The function `getHeight()` calculates the maximum depth of a tree structure by performing a
* breadth-first search.
* @returns the maximum depth or height of the tree.
*/
getHeight() {
let maxDepth = 0;
if (this) {
const bfs = (node: TreeNode<V>, level: number) => {
if (level > maxDepth) {
maxDepth = level;
}
const { _children } = node;
if (_children) {
for (let i = 0, len = _children.length; i < len; i++) {
bfs(_children[i], level + 1);
}
}
};
bfs(this, 0);
}
return maxDepth;
}
}

0
test/performance/data-structures/tree/tree.test.ts
View file

39
test/unit/data-structures/tree/tree.test.ts
View file

@ -1,39 +0,0 @@
import { TreeNode } from '../../../../src';
describe('TreeNode', () => {
it('should create a TreeNode with the given key and value', () => {
const node = new TreeNode<string>('1', 'Node 1');
expect(node.key).toBe('1');
expect(node.value).toBe('Node 1');
expect(node.children).toEqual([]);
});
it('should add children to the TreeNode', () => {
const parentNode = new TreeNode<string>('1', 'Parent Node');
const child1 = new TreeNode<string>('2', 'Child 1');
const child2 = new TreeNode<string>('3', 'Child 2');
parentNode.addChildren([child1, child2]);
expect(parentNode.children).toEqual([child1, child2]);
});
it('should calculate the height of the tree correctly', () => {
const rootNode = new TreeNode<string>('1', 'Root Node');
const child1 = new TreeNode<string>('2', 'Child 1');
const child2 = new TreeNode<string>('3', 'Child 2');
const grandchild1 = new TreeNode<string>('4', 'Grandchild 1');
const grandchild2 = new TreeNode<string>('5', 'Grandchild 2');
rootNode.addChildren([child1, child2]);
child1.addChildren([grandchild1]);
child2.addChildren([grandchild2]);
expect(rootNode.getHeight()).toBe(2); // Height of the tree should be 2
});
it('should handle nodes without children when calculating height', () => {
const rootNode = new TreeNode<string>('1', 'Root Node');
expect(rootNode.getHeight()).toBe(0); // Height of a single node should be 0
});
});