数据结构-树：JavaScript语言描述

树

树是一种非线性检索的数据结构，以分层的方式存储数据。树被用来存储具有层级关系的数据。树还被用来存储有序列表。

树的定义

树是由以边连接的节点组成。一棵树最上面的节点成为根节点，如果一个节点连接多个节点，称为父节点，它下面的节点成为子节点。一个节点可以有0、1或多个子节点，没有任何子节点的节点成为叶子结点。
二叉树的节点的子节点的数量不超过两个。从一个节点到另一个节点的一组边称为路径。以某种特定顺序访问所有节点叫做树的遍历。树可以分为几个层次，根节点为0层，树中任何一层节点可以看做是子树的根。树的层数就是树的深度。每个节点都有与之相关的值，通常成为键。
一个父节点的两个节点分别成为左节点和右节点。在一些二叉树的实现中，左节点包含一组特定的值，右节点包含一组特定的值。
二叉查找树是一种特殊的二叉树，它的较小的值放在左节点中，较大的值保存在右节点中。
树的构造函数，构造函数构造根节点，根节点是一个Node，存放根节点以及左子节点和右子节点。

function Tree() {
  function Node(key) {
    this.key = key;
    this.left = null;
    this.right = null;
  }
  this.root = null;

插入方法，向树中插入一个节点

  Tree.prototype.insert = function (key) {
    if (!this.root) {
      this.root = new Node(key);
    } else {
      let root = this.root;
      while (root) {
        if (key > root.key) {
          if (!root.right) {
            root.right = new Node(key);
            break;
          } else {
            root = root.right;
          }
        } else {
          if (!root.left) {
            root.left = new Node(key);
            break;
          } else {
            root = root.left;
          }
        }
      }
    }
  }

二叉查找树的遍历

中序遍历

中序遍历左子树，在访问根节点，中序遍历右子树

 Tree.prototype.middleOrderTraversal = function () {
    return this.middleOrderTraversalNode(this.root);
  }
  Tree.prototype.middleOrderTraversalNode = function (node) {
    let result = [];
    if (node !== null) {
      result = result.concat(this.middleOrderTraversalNode(node.left));
      result.push(node.key);
      result = result.concat(this.middleOrderTraversalNode(node.right));
    }
    return result;
  }

先序遍历

先访问根节点，再先序遍历左子树，最后先序遍历右子树

 Tree.prototype.preOrderTraversal = function () {
    return this.preOrderTraversalNode(this.root);
  }

  Tree.prototype.preOrderTraversalNode = function (node) {
    let result = [];
    if (node !== null) {
      result.push(node.key);
      result = result.concat(this.preOrderTraversalNode(node.left));
      result = result.concat(this.preOrderTraversalNode(node.right));
    }
    return result;
  }

后序遍历

先后序遍历左子树，再后序遍历右子树，最后访问根节点。

Tree.prototype.postOrderTraversal = function () {
    return this.postOrderTraversalNode(this.root);
  }
  Tree.prototype.postOrderTraversalNode = function (node) {
    let result = [];
    if (node !== null) {
      result = result.concat(this.postOrderTraversalNode(node.left));
      result = result.concat(this.postOrderTraversalNode(node.right));
      result.push(node.key);
    }
    return result;
  }

删除节点

删除节点首先判断当前节点是否包含待删除数据，如果包含则删除该节点；如果不包含，则比较当前节点的数据和待删除节点的数据，如果当前节点上的数据小于待删除节点的数据则移至当前节点的左节点继续比较；如果当前节点上的数据大于待删除节点的数据则移至当前节点的右节点继续比较。
如果删除的节点是叶子节点，则将从父节点指向他的链接指向null。
如果删除的节点只包含一个子节点，那么原本指向他的链接，指向它的子节点。
如果删除的节点包含两个节点，要么查找待删除节点左子树的最大值，要么查找待删除节点右子树的最小值。

Tree.prototype.remove = function (key) {
    let current = this.root;
    let parent = null;
    let isLeftChild = true;
    while (current.key !== key) {
      parent = current;
      if (key > current.key) {
        current = current.right;
        isLeftChild = false;
      } else if (key < current.left) {
        current = current.left;
        isLeftChild = true;
      }
      if (current === null) return false;
    }
    if (current.left === null && current.right === null) {
      if (current == this.root) {
        this.root = null;
      } else if (isLeftChild) {
        parent.left = null;
      } else {
        parent.right = null;
      }
    } else if (current.right === null) {
      if (current == this.root) {
        this.root = current.left;
      } else if (isLeftChild) {
        parent.left = current.left;
      } else {
        parent.right = current.left;
      }
    } else if (current.left == null) {
      if (current == this.root) {
        this.root = current.right;
      } else if (isLeftChild) {
        parent.left = current.right;
      } else {
        parent.right = current.right;
      }
    } else {
      let successor = this.getSuccessor(current);
      if (current == this.root) {
        this.root = successor;
      } else if (isLeftChild) {
        parent.left = successor;
      } else {
        parent.right = successor;
      }
    }
  }

获取后继节点，后继节点指的是比当前节点的值小的节点

 Tree.prototype.getSuccessor = function (delNode) {
    let successor = delNode;
    let current = delNode.right;
    let successorParent = delNode;
    while (current !== null) {
      successorParent = successor;
      successor = current;
      current = current.left;
    }

    if (successor !== delNode.right) {
      successorParent.left = successor.right;
      successor.right = delNode.right;
    }
    return successor;
  }