树状数据结构：用 JavaScript 实现二叉树

前端

2023-09-11 03:29:28

## 树状数据结构：分层数据的非线性组织

数据结构在计算机科学中至关重要，用于组织和存储数据。树状数据结构 是一种非线性的数据结构，它以分层的方式连接节点，形成一种树状结构。

## 树状数据结构的特性

树状数据结构由节点和边组成，其中节点包含数据，而边连接这些节点。每个节点最多可以有多个子节点，但只能有一个父节点。这种分层结构使树状数据结构在组织层次化数据时非常有用。

## 二叉树：一种特殊的树状数据结构

二叉树 是树状数据结构的一种特殊类型，具有以下特点：

每个节点最多有两个子节点，称为左子节点 和右子节点 。
从任何节点都不能通过边回到该节点，避免了循环。
树的高度 是树中从根节点到最远叶节点的最长路径的长度。

## JavaScript 中的二叉树实现

以下是用 JavaScript 实现二叉树的代码示例：

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

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

  // 插入一个新的节点
  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
    } else {
      this._insertNode(newNode, this.root);
    }
  }

  _insertNode(newNode, currentNode) {
    if (newNode.data < currentNode.data) {
      if (!currentNode.left) {
        currentNode.left = newNode;
      } else {
        this._insertNode(newNode, currentNode.left);
      }
    } else {
      if (!currentNode.right) {
        currentNode.right = newNode;
      } else {
        this._insertNode(newNode, currentNode.right);
      }
    }
  }

  // 删除一个节点
  remove(data) {
    this.root = this._removeNode(data, this.root);
  }

  _removeNode(data, currentNode) {
    if (!currentNode) return null;
    if (data === currentNode.data) {
      if (!currentNode.left && !currentNode.right) {
        return null;
      } else if (!currentNode.left) {
        return currentNode.right;
      } else if (!currentNode.right) {
        return currentNode.left;
      } else {
        const successor = this._getSuccessor(currentNode);
        currentNode.data = successor.data;
        currentNode.right = this._removeNode(successor.data, currentNode.right);
        return currentNode;
      }
    } else if (data < currentNode.data) {
      currentNode.left = this._removeNode(data, currentNode.left);
      return currentNode;
    } else {
      currentNode.right = this._removeNode(data, currentNode.right);
      return currentNode;
    }
  }

  _getSuccessor(currentNode) {
    let successor = currentNode.right;
    while (successor.left) {
      successor = successor.left;
    }
    return successor;
  }

  // 先序遍历：根节点、左子树、右子树
  preorderTraversal() {
    this._preorderTraversal(this.root);
  }

  _preorderTraversal(currentNode) {
    if (!currentNode) return;
    console.log(currentNode.data);
    this._preorderTraversal(currentNode.left);
    this._preorderTraversal(currentNode.right);
  }

  // 中序遍历：左子树、根节点、右子树
  inorderTraversal() {
    this._inorderTraversal(this.root);
  }

  _inorderTraversal(currentNode) {
    if (!currentNode) return;
    this._inorderTraversal(currentNode.left);
    console.log(currentNode.data);
    this._inorderTraversal(currentNode.right);
  }

  // 后序遍历：左子树、右子树、根节点
  postorderTraversal() {
    this._postorderTraversal(this.root);
  }

  _postorderTraversal(currentNode) {
    if (!currentNode) return;
    this._postorderTraversal(currentNode.left);
    this._postorderTraversal(currentNode.right);
    console.log(currentNode.data);
  }

  // 广度优先搜索：逐层访问所有节点
  breadthFirstSearch() {
    const queue = [];
    queue.push(this.root);
    while (queue.length) {
      const currentNode = queue.shift();
      console.log(currentNode.data);
      if (currentNode.left) queue.push(currentNode.left);
      if (currentNode.right) queue.push(currentNode.right);
    }
  }

  // 深度优先搜索：沿分支逐个访问节点
  depthFirstSearch() {
    const stack = [];
    stack.push(this.root);
    while (stack.length) {
      const currentNode = stack.pop();
      console.log(currentNode.data);
      if (currentNode.right) stack.push(currentNode.right);
      if (currentNode.left) stack.push(currentNode.left);
    }
  }
}