二叉排序树

最新推荐文章于 2022-04-01 16:49:42 发布
最新推荐文章于 2022-04-01 16:49:42 发布
阅读量163 收藏
点赞数
分类专栏： JavaScript 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beikepang/article/details/85219281
版权

#JavaScript 数据结构篇 之 BST

前言

有段时间没有写文章了，整个人感觉变得有点懒散了，大家可不要向我一样哦~
今天开始 seaconch 打算开始记录 JavaScript 数据结构的学习经历。
至此，开始。

课本：《学习JavaScript数据结构与算法 (第2版)》

术语：

  • BST (binary sort tree)
  • LST (left subtree)
  • RST (right subtree)

OUTLINE

  • 特性
  • 定义
  • 插入
  • 查找
  • 最大
  • 最小
  • 移除

特性

BST 有如下特性：

  • 若 LST 不为空，则 LST 所有节点值都 小 于它的根节点值
  • 若 RST 不为空，则 RST 所有节点值都 大 于它的根节点值
  • 左右子树也都是 BST
  • 没有重复键

定义

为了存储 BST，我们先定义一个 Node 类型，存储各个节点。

Node 节点的构造函数默认为其初始化 Subtree 都是 null。

/**
 * 节点
 */
class Node {

  constructor (key) {
    this.key = key;
    this.left = null;
    this.right = null;
  }

}

然后是 BST

BST 的类型我们只初始化了一个根节点 root。

/**
 * 二叉排序树
 */
class BinarySearchTree {

  constructor() {
    this.root = null;
  }

}

插入

插入节点只要遵循一个原则就好：大与 node.key 就向 node.right 中插入，小于 node.key 就向 node.left 插入。

首先定义私有函数。

const insertNode = Symbol('insertNode');

  /**
   * 插入节点
   */
  insert(key) {

    let newNode = new Node(key);
    if (this.root === null) this.root = newNode;
    else this[insertNode](this.root, newNode);

  }

  /**
   * 插入节点
   * @param {当前节点} node 
   * @param {新节点} newNode 
   */
  [insertNode] (node, newNode) {

    if (newNode.key < node.key) {

      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);

    }
  }

这里稍微的说明一下，之所以写成私有函数，无非就是为了不希望外部看到这些没必要的。

其实东西多了感觉也会乱糟糟的…

接下来为了查看一下效果，我们来写一个初始化 BST 的函数。

我们的目标是初始化一个这样的 BST。

在这里插入图片描述

/**
 * 初始化数据
 * @param {树} tree 
 */
function initialization(tree) {

  let treeKeys = [50, 25, 13, 5, 19, 35, 28, 49, 75, 64, 56, 74, 85, 79, 99];

  treeKeys.forEach( key => tree.insert(key) )

}

现在来试试实例化一个 BST 来看看效果。

let tree = new BinarySearchTree();

initialization(tree);

console.log(tree.root);

打印效果如图

在这里插入图片描述

查找

由:

  • 若 LST 不为空，则 LST 所有节点值都 小 于它的根节点值
  • 若 RST 不为空，则 RST 所有节点值都 大 于它的根节点值
  • 左右子树也都是 BST

因此我们可以相对快速的查找元素。

定义私有函数

const searchNode = Symbol('searchNode');

  /**
   * 是否存在目标 key
   */
  existKey(key) {
    return this[searchNode](this.root, key);
  }

  /**
   * 
   * @param {当前节点} node 
   * @param {key} key 
   */
  [searchNode] (node, key) {

    if (node === null) return false;
    
    if (key < node.key) return this[searchNode](node.left, key);
    
    else if (key > node.key) return this[searchNode](node.right, key);
    
    else return true;
    
  }

我们的思路是这样的：

如果要查找的 key值 小于 当前节点的 key值，则向 LST 继续查找;
如果要查找的 key值 大于 当前节点的 key值，则向 RST 继续查找;
如果要查找的 key值 等于 当前节点的 key值，则返回 true

运行效果如下：

在这里插入图片描述

最大值

由：

  • 若 RST 不为空，则 RST 所有节点值都 大 于它的根节点值
  • 左右子树也都是 BST

我们可以求得最大值

很明显是这样的

在这里插入图片描述

代码如下

定义私有函数

const maxNode = Symbol('maxNode');

  /**
   * 获取最大节点 key
   */
  max() {
    return this[maxNode](this.root);
  }

  /**
   * 获取最大节点 key
   * @param {节点} node 
   */
  [maxNode] (node) {

    if (node) {
    
      while (node && node.right !== null) {
      
        node = node.right;
      }
      return node.key;
    }
    return null;
  }

输出结果为：99

最小值

获取最小值的方法与最大值类似，只是方向变了一下

在这里插入图片描述

定义私有函数

const minNode = Symbol('minNode');

  /**
   * 获取最小节点 key
   */
  min() {
    return this[minNode](this.root);
  }

  /**
   * 获取最小节点 key
   * @param {节点} node 
   */
  [minNode] (node) {

    if (node) {
    
      while (node && node.left !== null) {
      
        node = node.left;
      }
      return node.key;
    }
    return null;
  }

运行结果自然是：5

移除

移除相对来说复杂一点，因为假如我们要移除的是一个父节点，那他们的子节点怎么办？

当然也是有相应的应对措施的。

  • 对于没有 subtree 的 node 来说，只需要把他们修改为 null 即可
  • 对于存在 subtree 的 node 来说，就要考虑所有情况分别处理
    • 当 LST === null 时 => RST 上前来顶替待删除节点的位置
    • 当 RST === null 时 => LST 上前来顶替待删除节点的位置
    • 当 LST && RST 都不是 null 时，由 RST 中最小节点上前来顶起待删除节点的位置

图例说明：

1. LST 等于 null

在这里插入图片描述

2. RST 等于 null

在这里插入图片描述

3. LST 和 RST 都不等于 null

在这里插入图片描述

定义私有函数

const removeNode = Symbol('removeNode');
const findMinNode = Symbol('findMinNode');

  /**
   * 删除节点
   */
  remove(key) {
    this[removeNode](this.root, key);
  }

  /**
   * 删除节点，返回删除后的 tree
   * @param {当前节点} node 
   * @param {key} key 
   */
  [removeNode] (node, key) {

    if (node === null) /** the tree is empty or does not have this key who you want to remove. */ return null;

    if (key < node.key) /** the key of currrent node is bigger than target key. */ {

      node.left = this[removeNode](node.left, key);
      return node;

    } else if (key > node.key) /** smaller */ {

      node.right = this[removeNode](node.right, key);
      return node;

    } else /** 相等 */ {

      if (node.left === null && node.right === null) {
        /**
         * 当前节点没有左右节点，可以放心删除
         */
        node = null;
        return node;
      }

      /**
       * 当前节点有一个节点，让子节点`顶`上来
       */
      if (node.left === null) {
        
        node = node.right;
        return node

      } else if (node.right === null) {

        node = node.left;
        return node;

      }

      /**
       * 来到这里代表当前节点有两个子节点
       */
      let aux = this[findMinNode](node.right); // 找到右节点的最小节点
      node.key = aux.key; // 把要删除的节点的 key 覆盖为右侧最小节点 key
      node.right = this[removeNode](node.right, aux.key); // 重构 right side tree (删除上面找到的 aux 节点)
      return node;
    }
  }

  /**
   * 返回目标节点分支下最小节点
   * @param {目标节点} node 
   */
  [findMinNode] (node) {

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

好了，现在来一起运行一下，看一下效果吧

在这里插入图片描述

oh, sorry…

源码如下：

/**
 * 节点
 */
class Node {

  constructor (key) {
    this.key = key;
    this.left = null;
    this.right = null;
  }
}

const insertNode = Symbol('insertNode');
const removeNode = Symbol('removeNode');
const findMinNode = Symbol('findMinNode');
const minNode = Symbol('minNode');
const maxNode = Symbol('maxNode');
const searchNode = Symbol('searchNode');

/**
 * 二叉排序树
 */
class BinarySearchTree {

  constructor() {
    this.root = null;
  }

  /**
   * 插入节点
   */
  insert(key) {

    let newNode = new Node(key);
    if (this.root === null) this.root = newNode;
    else this[insertNode](this.root, newNode);

  }

  /**
   * 插入节点
   * @param {当前节点} node 
   * @param {新节点} newNode 
   */
  [insertNode] (node, newNode) {

    if (newNode.key < node.key) {

      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);

    }
  }

  /**
   * 删除节点
   */
  remove(key) {
    this[removeNode](this.root, key);
  }

  /**
   * 删除节点，返回删除后的 tree
   * @param {当前节点} node 
   * @param {key} key 
   */
  [removeNode] (node, key) {

    if (node === null) /** the tree is empty or does not have this key who you want to remove. */ return null;

    if (key < node.key) /** the key of currrent node is bigger than target key. */ {

      node.left = this[removeNode](node.left, key);
      return node;

    } else if (key > node.key) /** smaller */ {

      node.right = this[removeNode](node.right, key);
      return node;

    } else /** 相等 */ {

      if (node.left === null && node.right === null) {
        /**
         * 当前节点没有左右节点，可以放心删除
         */
        node = null;
        return node;
      }

      /**
       * 当前节点有一个节点，让子节点`顶`上来
       */
      if (node.left === null) {
        
        node = node.right;
        return node

      } else if (node.right === null) {

        node = node.left;
        return node;

      }

      /**
       * 来到这里代表当前节点有两个子节点
       */
      let aux = this[findMinNode](node.right); // 找到右节点的最小节点
      node.key = aux.key; // 把要删除的节点的 key 覆盖为右侧最小节点 key
      node.right = this[removeNode](node.right, aux.key); // 重构 right side tree (删除上面找到的 aux 节点)
      return node;
    }
  }

  /**
   * 返回目标节点分支下最小节点
   * @param {目标节点} node 
   */
  [findMinNode] (node) {

    while (node && node.left !== null) {

      node = node.left;
    }
    return node;
  }

  /**
   * 获取最小节点 key
   */
  min() {
    return this[minNode](this.root);
  }

  /**
   * 获取最小节点 key
   * @param {节点} node 
   */
  [minNode] (node) {

    if (node) {

      while (node && node.left !== null) {

        node = node.left;
      }
      return node.key;
    }
    return null;
  }

  /**
   * 获取最大节点 key
   */
  max() {
    return this[maxNode](this.root);
  }

  /**
   * 获取最大节点 key
   * @param {节点} node 
   */
  [maxNode] (node) {

    if (node) {

      while (node && node.right !== null) {

        node = node.right;
      }
      return node.key;
    }
    return null;
  }

  /**
   * 是否存在目标 key
   */
  existKey(key) {
    return this[searchNode](this.root, key);
  }

  /**
   * 
   * @param {当前节点} node 
   * @param {key} key 
   */
  [searchNode] (node, key) {

    if (node === null) return false;

    if (key < node.key) return this[searchNode](node.left, key);

    else if (key > node.key) return this[searchNode](node.right, key);

    else return true;

  }
}


/**
 * 初始化数据
 * @param {树} tree 
 */
function initialization(tree) {

  let treeKeys = [50, 25, 13, 5, 19, 35, 28, 49, 75, 64, 56, 74, 85, 79, 99];

  treeKeys.forEach( key => tree.insert(key) )

}

let tree = new BinarySearchTree();

initialization(tree);

console.log('the min node.key is: ', tree.min());
console.log('the max node.key is: ', tree.max());

let tempKey = 49;
console.log('the key of [', tempKey, ']', tree.existKey(tempKey) ? 'real' : 'not', 'exist.');

tree.remove(49)
console.log('remove key [', tempKey, ']');

console.log('the key of [', tempKey, ']', tree.existKey(tempKey) ? 'real' : 'not', 'exist.');

continue…

bey6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
手写二叉排序树
qq_42921539的博客
12-10 522
手写二叉排序树 今天我用自己所理解的方式手写一个二叉排序树 首先我先介绍下二叉排序树的插入规则：拿 “ 5 , 2 , 7 , 3 , 4 , 1 , 6 ” 举例，首先取数组的第一个 5 插入到二叉树里面，当中根节点，然后再拿第二个2往下面插（因为这里是二叉树，所以一个节点最多有2个分支），这里拿第二个数和根节点进行比较，如果比它小就放它的左边，大即右边。很显然，当 2 插入到二叉树里面...
一步一步写算法--二叉排序树
lskyne的专栏
06-13 1613
BST： 1，若左子树非空，则左子树上所有结点关键字值均小于根结点的关键值 2，若右子树非空，则右子树上所有结点关键字值均大于根结点的关键字值 3，左右子树本身也分别是一颗二叉排序树 源程序 #include #include typedef int ElemType; typedef struct BSTNode{ ElemType data; stru
手写实现二叉排序树
11-16 416
实现二叉排序树的增，删和便利算法 package com.example.admin.myapplication.tree; /** * 二叉排序树 * Created by admin on 2017/11/16. */ public class OrderTree { public static class Node { int value;
自己动手写数据结构（11）——二叉排序树
MeteorChenBo的博客
12-28 623
上一篇博客写了有序表查找，其中三种方法的基本思想都是二分查找，他们的查找的时间复杂度均为 O(logn)，我们发现有序表的查找效率挺高的了，但是插入效率很低，插入的时间复杂度仍然是O(n)，为了提高插入效率，有人提出了二叉排序树的数据结构。 一、定义 二叉排序树，又称二叉查找树。它或者是一颗空树，或者是一棵具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若...
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
C语言实现二叉排序树线索化再中序遍历
ENAIC__suger的博客
06-02 311
#include<stdio.h> #include<stdlib.h> #define M 1000 struct ThrTreeNode; typedef struct ThrTreeNode *PThrTreeNode; struct ThrTreeNode{ int info; PThrTreeNode llink,rlink; int ltag,rt...
树形结构：二叉排列树，二叉搜索树
weixin_40759186的博客
12-22 185
二叉排列树，二叉搜索树 这个数听见得比较多，含义是：左边&lt;=中间&lt;=右边，换句话来说使用中序遍历最后得到结果就是一个有序得序列。 建立一颗二叉排列树 class BinTNode: def __init__(self,data=None,left =None,right =None): self.data =data self.left =lef...
如何写一棵简单的二叉查找树
潜心种树
12-30 628
二叉查找树二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），亦称二叉搜索树。 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若右子树不空，则右子树上所有结点的值均大于它的根结点的值 左、右子树也分别为二叉排序树； 这样的树有一个特点：所有节点在x轴的映射是有序的。 一棵查找树的主要功能有：插入，查找，删除。 除此之外还需要一些辅助
二叉树的线索化
Michael__Wu的博客
07-23 89
1 简介 深度优先的二叉树遍历方法有先序, 中序和后序. 那么一棵有n个节点的树, 其一共会存储2n个指针, 但是因为只有n - 1条边, 所以只有n - 1个指针会被存储, 剩下的n + 1都会存为nullptr, 那么可以把所有的空指针利用起来. 其中如果某个节点的左子节点为空的话, 可以按照当前遍历方式(先序, 中序, 后序)存储其前驱结点, 右子节点为空的话, 可以存储后继节点. 2 结构 普通的二叉树节点的结构为: struct TreeNode { int val; T
线索化二叉树（排序生成树）
RookiChen的博客
04-18 272
#include <iostream> #include <stdio.h> #include <conio.h> using namespace std; enum class Tag { prior , rear}; // 枚举类型，prior为0，rear为1 // prior代表指向左右节点，rear为线索，代表指向前一个节点 template <class T> class BTNode { public: BTNode() { d
数据结构实验课：打印树形二叉搜索树；用睡眠排序
//柏拉图的双斜杠
11-30 422
下面是作业要求： ICSI 213 Data Structures Lab Week 12 Lab 7, November 27th. Topics:  Binary Search Tree Study materials:  See lecture notes and relevant materials from the textbook.Instructions: Writ...
二叉树，顺序存储二叉树，线索化二叉树，二叉排序树，AVL树，赫夫曼树(文件压缩，解压)
Dichotomy_的博客
02-17 311
文章目录二叉树二叉树的三种遍历方式顺序存储二叉树线索化二叉树二叉排序树 二叉树 二叉树：每个节点最多只用两个节点的树。 二叉树的三种遍历方式 前序遍历：先找到根节点，然后左节点，最后右节点。 中序遍历：先左节点，根节点，右节点。 后序遍历：先左节点，右节点，根节点。 JAVA代码实现： // 创建节点 @Data class Node { // 存储数据 private int no; ...
二叉树的创建、线索化以及遍历
weixin_42448226的博客
03-03 343
#include&lt;iostream&gt; #define MAX 20 using namespace std; typedef struct node{ char data; struct node * lchild,* rchild; int ltag, rtag; }TBTNode; //节点类型 TBTNode * pre;void Thread(T...
看图说话之二叉排序树
涂印的博客
10-19 2460
介绍了二叉排叙树(BST)的基本原理，重点介绍了插入，删除，建树操作，给出了详细的实现步骤，并且用java代码实现
数据结构-二叉排序树（图文详细版）
热门推荐
淡沫初夏zz的博客
01-17 5万+
二叉排序树
二叉排序树详解
云杉木屋
04-01 2万+
摘要：本篇笔记专门介绍二叉排序树，重点讲解了二叉排序树的特性，以及二叉排序树各方面的基本实现。
二叉排序树与平衡二叉排序树的区别
最新发布
04-09
二叉排序树（Binary Search Tree，BST）是一种特殊的二叉树，它满足以下性质： 1. 左子树上的所有节点的值都小于根节点的值。 2. 右子树上的所有节点的值都大于根节点的值。 3. 左右子树也都是二叉排序树。 而平衡二叉排序树（Balanced Binary Search Tree）是在二叉排序树的基础上进行了平衡操作，以保证树的高度尽可能地小，从而提高查找、插入和删除等操作的效率。 区别如下： 1. 平衡性：二叉排序树没有对树的平衡性做出要求，因此可能出现极端情况下树的高度非常大，导致查找、插入和删除等操作的效率下降。而平衡二叉排序树通过旋转、插入和删除等操作来保持树的平衡，使得树的高度尽可能地小，提高了操作效率。 2. 插入和删除操作：在二叉排序树中，插入和删除操作可能会破坏树的有序性，需要进行调整来保持有序性。而在平衡二叉排序树中，插入和删除操作不仅需要保持有序性，还需要保持树的平衡性，因此需要进行更多的调整操作。 3. 效率：由于平衡二叉排序树保持了树的平衡性，因此在查找、插入和删除等操作上的效率要优于普通的二叉排序树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值