Nodejs tree data structure for javascript.

Nodejs tree data structure for javascript.

tree data structure for javascript. https://github.com/brighthas/tree-data

6 回复

Node.js Tree Data Structure for JavaScript

在Node.js中构建树形数据结构是一种常见的需求，特别是在处理具有层次关系的数据时。本文将介绍如何在JavaScript中实现一个简单的树数据结构，并提供一些基本的操作方法。

示例代码

首先，我们来创建一个简单的树节点类 TreeNode，该类将包含节点的值、子节点列表等属性：

class TreeNode {
    constructor(value) {
        this.value = value;
        this.children = [];
    }

    // 添加子节点
    addChild(childNode) {
        this.children.push(childNode);
    }

    // 查找子节点
    findChild(value) {
        for (const child of this.children) {
            if (child.value === value) {
                return child;
            }
        }
        return null;
    }

    // 遍历树
    traverse(callback) {
        callback(this);
        for (const child of this.children) {
            child.traverse(callback);
        }
    }
}

示例用法

接下来，我们可以通过实例化 TreeNode 类并添加子节点来构建一个树：

// 创建根节点
const rootNode = new TreeNode('root');

// 添加子节点
const childNode1 = new TreeNode('child1');
const childNode2 = new TreeNode('child2');

rootNode.addChild(childNode1);
rootNode.addChild(childNode2);

// 添加子节点的子节点
const grandChildNode = new TreeNode('grandChild');
childNode1.addChild(grandChildNode);

// 遍历树
rootNode.traverse(node => console.log(node.value));

上述代码将输出：

root
child1
grandChild
child2

解释

  • TreeNode 类：定义了树节点的基本属性和方法。每个节点都有一个值（value）和一个子节点数组（children）。
  • addChild 方法：用于向当前节点添加子节点。
  • findChild 方法：用于查找具有特定值的子节点。
  • traverse 方法：用于遍历树的所有节点，可以传入一个回调函数来处理每个节点。

通过这种方式，我们可以轻松地创建、管理和遍历复杂的树形数据结构。这种实现方式适用于多种应用场景，如文件系统、组织结构、菜单项等。


问下怎么玩?

不错。需要查询功能。

https://github.com/brighthas/tree-data

有API说明

https://github.com/brighthas/tree-data#about-node-object 增加了API doc

Node.js Tree Data Structure for JavaScript

在Node.js中实现一个树数据结构可以非常灵活。这里我将展示一个简单的二叉树的实现，并提供一些基本的操作方法。

示例代码

class TreeNode {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

class BinaryTree {
    constructor() {
        this.root = null;
    }

    insert(value) {
        const newNode = new TreeNode(value);
        if (this.root === null) {
            this.root = newNode;
        } else {
            this.insertNode(this.root, newNode);
        }
    }

    insertNode(node, newNode) {
        if (newNode.value < node.value) {
            if (node.left === null) {
                node.left = newNode;
            } else {
                this.insertNode(node.left, newNode);
            }
        } else {
            if (node.right === null) {
                node.right = newNode;
            } else {
                this.insertNode(node.right, newNode);
            }
        }
    }

    inOrderTraverse(callback) {
        this.inOrderTraverseNode(this.root, callback);
    }

    inOrderTraverseNode(node, callback) {
        if (node !== null) {
            this.inOrderTraverseNode(node.left, callback);
            callback(node.value);
            this.inOrderTraverseNode(node.right, callback);
        }
    }

    search(value) {
        return this.searchNode(this.root, value);
    }

    searchNode(node, value) {
        if (node === null) {
            return false;
        }

        if (value < node.value) {
            return this.searchNode(node.left, value);
        } else if (value > node.value) {
            return this.searchNode(node.right, value);
        } else {
            return true;
        }
    }
}

// 示例使用
const tree = new BinaryTree();
tree.insert(11);
tree.insert(7);
tree.insert(15);
tree.insert(5);
tree.insert(3);
tree.insert(9);

console.log("In-order traversal:");
tree.inOrderTraverse((value) => console.log(value));

console.log("Search result for 9:", tree.search(9)); // true
console.log("Search result for 8:", tree.search(8)); // false

解释

  1. TreeNode 类: 表示树中的节点，包含值、左子节点和右子节点。
  2. BinaryTree 类: 实现了插入、中序遍历和搜索功能。
    • insert(value): 插入一个新节点到树中。
    • insertNode(node, newNode): 递归地找到合适的位置插入新节点。
    • inOrderTraverse(callback): 中序遍历树，并对每个节点执行回调函数。
    • search(value): 搜索指定值是否存在于树中。

通过这种方式，你可以轻松地扩展这个基础的二叉树实现，以支持更多操作，如删除节点、前序遍历等。

回到顶部