JS中数据结构之二叉查找树

树是一种非线性的数据结构,以分层的方式存储数据。在二叉树上进行查找非常快,为二叉树添加或删除元素也非常快。

一棵树最上面的节点称为根节点,如果一个节点下面连接多个节点,那么该节点称为父节点,它下面的节点称为子节点。一个节点可以有 0 个、1 个或多个子节点,没有任何子节点的节点称为叶子节点。

二叉树是一种特殊的树,它的子节点个数不超过两个,一个父节点的两个子节点分别称为左节点和右节点。树中任何一层的节点可以都看做是子树的根,树的层数就是树的深度。

二叉查找树是一种特殊的二叉树,相对较小的值保存在左节点中,较大的值保存在右节点中。

《JS中数据结构之二叉查找树》

二叉查找树的实现

node 类定义节点

function Node(data, left, right) {
  this.data = data;
  this.left = left;
  this.right = right;
  this.show = show;
}

show() 方法展示节点数据

function show() {
  return this.data;
}

创建 BST 类表示二叉查找树。该类的构造函数将根节点初始化为 null

function BST() {
  this.root = null;
  this.insert = insert;
  this.inOrder = inOrder;
  this.preOrder = perOrder;
  this.postOrder = postOrder;
  this.update = update;
  this.getMin = getMin;
  this.getMax = getMax;
  this.find = find;
  this.remove = remove;
}

insert() 方法向树中加入新节点。首先创建一个 Node 对象,将数据传入该对象保存。 其次检查 BST 是否有根节点,如果没有,那么该节点就是根节点;否则,就需要准备遍历 BST,找到插入的适当位置。

查找正确的插入位置的算法逻辑:

(1) 设根节点为当前节点。

(2) 如果待插入节点保存的数据小于当前节点,则设新的当前节点为原节点的左节点;反之,执行第 4 步。

(3) 如果当前节点的左节点为 null,就将新的节点插入这个位置,退出循环;反之,继续执行下一次循环。

(4) 设新的当前节点为原节点的右节点。

(5) 如果当前节点的右节点为 null,就将新的节点插入这个位置,退出循环;反之,继续执行下一次循环。

function insert(data) {
  var n = new Node(data, null, null);
  if (this.root == null) {
    this.root = n;
  } else {
    var current = this.root;
    var parent;
    while (true) {
      parent = current;
      if (data < current.data) {
        current = current.left;
        if (current == null) {
          parent.left = n;
          break;
        }
      } else {
        current = current.right;
        if (current == null) {
          parent.right = n;
          break;
        }
      }
    }
  }
}

遍历二叉查找树

① NLR:先序遍历 ——访问根结点的操作发生在遍历其左右子树之前。 ② LNR:中序遍历 ——访问根结点的操作发生在遍历其左右子树之中(间)。 ③ LRN:后序遍历 ——访问根结点的操作发生在遍历其左右子树之后。
《JS中数据结构之二叉查找树》 中序遍历以升序访问树中所有节点,先访问左子树,再访问根节点,最后访问右子树

function inOrder(node) {
  if (!(node == null)) {
    inOrder(node.left);
    console.log(node.show() + " ");
    inOrder(node.right);
  }
}  //上图中序遍历顺序: 3 16 22 23 37 45 99

先序遍历

function preOrder(node) {
  if (!(node == null)) {
    putstr(node.show() + " ");
    preOrder(node.left);
    preOrder(node.right);
  }
}  //上图先序遍历顺序:23 16 3 22 45 37 99

后序遍历

function postOrder(node) {
  if (!(node == null)) {
    postOrder(node.left);
    postOrder(node.right);
    putstr(node.show() + " ");
  }
}  //上图后序遍历顺序:3 22 16 37 99 45 23

二叉树上查找最小值和最大值

function getMin() {  //遍历左子树,直到找到最后一个节点
  var current = this.root;
  while (!(current.left == null)) {
    current = current.left;
  }
  return current.data;
}

function getMax() {  //遍历右子树,直到找到最后一个节点,
  var current = this.root;
  while (!(current.right == null)) {
    current = current.right;
  }
  return current.data;
}

find() 方法查找给定值,如果找到就返回保存该值的节点;如果没找到,该方法返回 null

function find(data) {
  var current = this.root;
  while (current != null) {
    if (current.data == data) {
      return current;
    } else if (data < current.data) {
      current = current.left;
    } else {
      current = current.right;
    }
  }
  return null;
}

从二叉查找树上删除节点

BST 上删除节点是最复杂的操作。如果删除没有子节点的节点,那么非常简单;如果节点只有一个子节点就比较复杂;而删除包含两个子节点的节点最复杂。

从 BST 中删除节点的第一步是判断当前节点是否是待删除的数据,如果是,则删除该节点;否则就比较当前节点上的数据和待删除的数据。如果待删除数据小于当前节点上的数据,则移至当前节点的左子节点继续比较;如果删除数据大于当前节点上的数 据,则移至当前节点的右子节点继续比较。

如果待删除节点是叶子节点,那么只需要将从父节点指向它的链接指向 null。 如果待删除节点只包含一个子节点,那么就让原本指向它的节点指向它的子节点。 最后,如果待删除节点包含两个子节点,正确的做法有两种:要么查找待删除节点左子树上的最大值,要么查找其右子树上的最小值。下面的函数选择的是后一种方式。

整个删除过程由两个方法完成。remove() 方法只是简单地接受待删除数据,调用 removeNode() 删除它,removeNode()方法才是完成主要工作的方法。

function remove(data) {
  root = removeNode(this.root, data);
}

function removeNode(node, data) {
  if (node == null) {
    return null;
  }
  if (data == node.data) {
    // 没有子节点的节点
    if (node.left == null && node.right == null) {
      return null;
    }
    // 没有左子节点的节点
    if (node.left == null) {
      return node.right;
    }
    // 没有右子节点的节点
    if (node.right == null) {
      return node.left;
    }
    // 有两个子节点的节点
    var tempNode = getSmallest(node.right);  //查找右子树上的最小值
    node.data = tempNode.data;    //将最小值复制到待删除节点
    node.right = removeNode(node.right, tempNode.data);  //最后删除最小值节点
    return node;
  } else if (data < node.data) {
    node.left = removeNode(node.left, data);
    return node;
  } else {
    node.right = removeNode(node.right, data);
    return node;
  }
}

function getSmallest(node){
  while(node.left != null) {
    node = node.left;
  }
  return node;
}

计数:记录在一组数据集中数据出现的次数。如果该数据尚未在 BST 中出现,就将其加入 BST;如果已经出现,就将出现的次数加 1。

修改 Node 对象,为其增加一个记录数据出现频次的成员

function Node(data, left, right) {
  this.data = data;
  this.count = 1;
  this.left = left;
  this.right = right;
  this.show = show;
}

update() 方法当数据已经存在二叉树中时更新数据出现的频次

function update(data) {
  var grade = this.find(data);  //当找到数据即返回含有该数据的节点,当没找到数据时(即数据不存在当前二叉树中)返回null
  grade.count++;
  return grade;
}

 

    原文作者:wenxuehai
    原文地址: https://www.cnblogs.com/wenxuehai/p/10302903.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞