javascript数据结构7-二叉搜索树（BST）

最新推荐文章于 2024-07-25 09:24:40 发布
最新推荐文章于 2024-07-25 09:24:40 发布
阅读量952 收藏
点赞数
分类专栏： javascript数据结构与算法 文章标签： javascript 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/future_todo/article/details/52765092
版权

二叉树 ：

这里写图片描述

闲话少说，直接上代码：

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>BST</title>
</head>
<body>
<script>
  //结点
    function Node(data,left,right){
        this.data=data;
        this.left=left;
        this.right=right;
        this.floor=floor;  //层数
        this.show=show;
    }
    function floor(){
      return this.floor;
    }
    function show(){
        return this.data;
    }

    function BST(){
        this.root=null;
        this.insert=insert; //插入数据
        this.inOrder=inOrder; //中序排列，详细见后面解释
        this.preOrder=preOrder; //先序排序
        this.postOrder=postOrder; //后续排序
        this.getMax=getMax; //得到最大值
        this.getMin=getMin; //得到最小值
        this.find=find; //查找
        this.remove=remove; //删除节点
    }

    function insert(data){
       var n=new Node(data,null,null);
        if(this.root==null){
            this.root=n;
            this.root.floor=1;
        }else{
            var current=this.root;
            var parent;
                var c=1;    
            while(true){
                parent=current;  
                if(data<current.data){
                        current=current.left;
                        c++;  //计算层数的计数器加1
                    if(current==null){
                        parent.left=n;
                        parent.left.floor=c;
                        break;
                    }
                }else{
                    current=current.right;
                        c++;   //加1
                    if(current==null){
                        parent.right=n;
                        //rHeight++;
                        // console.log("**"+rHeight+"**");
                        parent.right.floor=c;
                        break;
                    }
                }
            }
        }
    }
  //中序遍历
  function inOrder(node){
      if(!(node==null)){
          inOrder(node.left);
          document.write(node.show()+" ");
          document.write("层数"+node.floor+"<br/>");
          inOrder(node.right);
      }
       //console.count("inOrder被执行的次数");
  }
  //先序遍历
   function preOrder(node){
      if(!(node==null)){
          document.write(node.show()+" ");
          preOrder(node.left);
          preOrder(node.right);
      }
  }

  //后序遍历
   function postOrder(node){
      if(!(node==null)){
          postOrder(node.left);        
          postOrder(node.right);
            document.write(node.show()+" ");
      }
  }

  //查找最大值
  function getMax(){
        var current=this.root;
        while(!(current.right==null)){
            current=current.right;
        }
        return current.data;
  }
  //查找最小值
   function getMin(){
        var current=this.root;
        while(!(current.left==null)){
            current=current.left;
        }
        return current.data;
  }
  //带参数---查找最小值
  function getSmallest(node){
        while(!(node.left==null)){
            node=node.left;
        }
     return node;
  }
  //查找
  function find(data){
        var current=this.root;
        while(current!=null){
            if(current.data==data){
              document.write("<br/>找到【"+data+"】节点<br/>");
              return current;
            }else if(data<current.data){
               current=current.left;
            }else{
               current=current.right;
            }

        }
     document.write("<br/>没有找到【"+data+"】 节点<br/>");
//      return current;
  }

  //删除节点-详细解释见后后面
     function remove(data) {
            root = removeNode(this.root, data);
            //其实root=没有用处，只是保留了函数执行的地址
    }
    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);
              // console.log(node);
                return node;
            }
}

  //测试
      var nums=new BST();
      nums.insert(56);
      nums.insert(22);  
      nums.insert(81);
      nums.insert(10);
      nums.insert(30);
      nums.insert(77);
      nums.insert(92);
      nums.insert(100);
      document.write("*****************中序遍历***************</br>");
      inOrder(nums.root);
      document.write("</br>***************先序遍历***************</br>");
      preOrder(nums.root);
      document.write("</br>***************后序遍历***************</br>");
      postOrder(nums.root);
      //nums.show();
      //console.log(nums);  
      document.write("</br>***************最大值/最小值************</br>");
      document.write(nums.getMax()+"/"+nums.getMin());
      document.write("</br>***************查找************</br>");
      nums.find(100);
      document.write("</br>***************删除节点81后************</br>");
      nums.remove(81);
      console.log(nums);
      preOrder(nums.root);
</script>
</body>
</html>

结果：
这里写图片描述

遍历

中序遍历：
这里写图片描述
理解双层递归

function inOrder(node) {
    if (!(node == null)) {
        inOrder(node.left);                             //@1
        document.document(node.show() + " ");           //@2
        inOrder(node.right);                            //@3
    }
}


inOrder(nums.root);    //开始执行

从根节点开始：
这里写图片描述

这里写图片描述
这里写图片描述

删除节点：

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

简单接受待删除的数据，具体执行是removeNode函数；

function removeNode(node, data) {
    }

待删除的节点是：
1.叶子结点，只需要将从父节点只想它的链接指向null；

if (node.left == null && node.right == null) {
        return null;   
    }
if (node.left == null && node.right == null) {
                return null;   //递归，找到节点置为空即可
            }
               //其他情况
            }
            else if (data < node.data) {
                node.left = removeNode(node.left, data);  //#1            
                return node; //#2
            }
            else {
                node.right = removeNode(node.right, data);//#3
                return node; //#4
            }

通过if else逻辑找到node节点

//#1  node.left=null(后面的函数递归后返回的值)
//#3  node.right=null(后面的函数递归后返回的值)

2.只包含一个子节点，原本指向它的节点指向它的子节点。
3.左右子树都有的时候。两种做法：找到左子树的最大值或者右子树的最小值。这里我们用第二种。

  • 查找右子树的最小值，创建一个临时的节点tempNode。
  • 将临时节点的值赋值给待删除节点
  • 删除临时节点

注意：

//#2 //#4必须有，如果没有，则删除节点下面的所有子树都将被删除。
真个过程举个形象的说明，遍历的时候把节点之间的链条解开进行查询，return node；递归查询到最后一级后，由下向上对链条进行缝合。

TechFE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于JavaScript数据结构实现的二叉排序树社会关系网【100012932】
07-14
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值，且左子树中的所有节点的键值都小于当前节点，右子树中的所有节点的键值都大于当前节点。...
【前端算法系列】二叉搜索树
越思考越清晰
01-11 398
二叉搜索树特点：可为空树；或满足左子节点（最小） <= 根节点 <= 右子节点（最大），不存在相等值的节点；具有有序性 搜索效率之高： 1、线性查找：从左到右一个个查找，找10次。 2、比如搜索10，10大于9，又是二叉搜索树，所以一定在右边。找到13，10又比13小，所以找左边11；10又比11小，找左边 3、二叉查找树：如果这个数组是有序的，可以从中间开始查找，找到中间值8，10比8大，找右边；再进行二分，找中间值11，10小于11，最终找到10 4、哈希表，是无序的，会造成空间浪费 应用
JavaScript 中的二叉树以及二叉搜索树的实现及应用
weixin_38169769的博客
08-04 225
接下来让我们一起来探讨js数据结构中的树。这里的树类比现实生活中的树，有树干，树枝，在程序中树是一种数据结构，对于存储需要快速查找的数据非有用，它是一种分层数据的抽象模型。一个树结构包含一系列存在父子关系的节点。每个节点都有一个父节点以及零个或多个子节点。如下所以为一个树结构：） 和树相关的概念：1.子树：由节点和他的后代构成，如上图标示处。2.深度：节点的深度取决于它祖节点的数量，比如节点5...
javascript数据结构之二叉搜索树实现方法
11-24
二叉搜索树是一种特殊的数据结构，它在计算机科学中用于高效地存储和检索有序数据。在JavaScript中，我们可以创建一个二叉搜索树类来实现这些功能。以下是对标题和描述中提到的知识点的详细说明： 1. **二叉搜索树...
js代码-二叉搜索树的创建，插入，遍历
07-16
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树数据结构，它具有以下特性： 1. **定义**：在二叉搜索树中，每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用和一个指向右子节点的...
js代码-12.3 二叉搜索树-删除节点
07-16
在JavaScript编程中，二叉搜索树（Binary Search Tree，BST）是一种特殊的数据结构，它具有以下特性：每个节点的左子树只包含小于该节点的元素，右子树只包含大于该节点的元素。这样的性质使得二叉搜索树在查找、...
javascript数据结构8-图（Graph）
前端-后端学习之路
10-09 1926
图（graph） 图由边的集合及顶点的集合组成 有向图： 无向图： 代码： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Graph</title> </head> <body> <script> function Graph(v){ this.vert
javascript数据结构5-链表（包括循环链表 双向链表）
前端-后端学习之路
10-09 1466
1.一般链表图解链表： 链表 实现：<!doctype html> <html> <head> <meta charset="utf-8" > </head> <body> <script> function Node(ele) { this.ele=ele; this.next=null; } fun
javascript数据结构9-排序
前端-后端学习之路
10-09 960
排序算法 1. 基本排序 - 冒泡排序 - 选择排序 - 插入排序 2. 高级排序 - 希尔排序 - 归并排序 - 快速排序 - 基数排序 （见【Javascript】四、JS数据结构-队列2-基数排序） 注释：完整例子在最后，可以copy运行。 测试数据平台： //数组平台 function
javascript数据结构6-字典 散列 集合
前端-后端学习之路
10-09 465
6.1 字典字典是一种以键- 值对形式存储数据的数据结构，就像电话号码簿里的名字和电话号码一<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>字典sample</title> </head> <body> <script> function Dictionary(){ this.add =
javascript数据结构5-链表2 存放点数据（x,y）
前端-后端学习之路
10-09 435
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Document</title> </head> <body> <script>function Node(element){ this.element=element; this.next=null; } function Point(x,y){
javascript数据结构4-队列
前端-后端学习之路
10-09 369
队列是一种先进先出（FIFO，first-in-first-out）的数据结构javascript代码实现队列：<!doctype html> <html> <head> <meta charset=utf-8 /> <title>Queue Sample</title> </head> <body> <script type="text/javascript"> /*
javascript数据结构4-队列2-基数排序
前端-后端学习之路
10-09 350
第一次按个位上的数字进行排序，第二次按十位上的数字进行排序 排序：91, 46, 85, 15, 92, 35, 31, 22 经过基数排序第一次扫描之后，数字被分配到如下盒子中：Bin 0: Bin 1: 91, 31 Bin 2: 92, 22 Bin 3: Bin 4: Bin 5: 85, 15, 35 Bin 6: 46 Bin 7: Bin 8: Bin 9:根据盒子的顺序，对数字进
javascript数据结构1-数组
前端-后端学习之路
10-09 330
书籍： 数据结构与算法javascript描述 数组比较简单，这里只是简单介绍：1.使用数组1.1 创建数组//第一种形式 var numbers = new Array(3); //第二种形式 var numbers = [7,4,1776]; 大多数JavaScript 专家推荐使用[]操作符，和使用Array 的构造函数相比，这种方式被认为效率更高（new创建的对象，会一直存在于内存中）1
javascript数据结构2-列表
前端-后端学习之路
10-09 255
1. 类型定义 listSize（属性） 列表的元素个数 pos（ 属性） 列表的当前位置 length（ 属性） 返回列表中元素的个数 clear（ 方法） 清空列表中的所有元素 toString（ 方法） 返回列表的字符串形式 getElement（ 方法） 返回当前位置的元素 in
javascript数据结构3-栈
前端-后端学习之路
10-09 253
后进先出（LIFO,last-in-first-out）的数据结构 类比：堆叠盘子，只能从上面拿走盘子<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>栈</title> </head> <body> <script type="text/javasc
【React 】开发环境搭建详细指南
lph159的博客
07-24 1235
无论你是刚刚开始学习 React，还是希望在现有项目中采用 React 技术，搭建一个高效的开发环境都是至关重要的。本文将详细介绍如何从零开始搭建 React 开发环境，涵盖所需的工具和最佳实践，帮助你快速启动并顺利进行开发。Visual Studio Code（VS Code）是目前最流行的代码编辑器之一，提供了丰富的扩展和强大的功能。如果你希望对项目的配置有更多的控制，可以选择手动配置 React 项目。下载并安装最新版本的 Node.js，安装 Node.js 后，npm 会自动安装。
在Vue程序中，如何检测用户的登录状态并跳转到对应页面
最新发布
exlink2012的专栏
07-25 381
通过以上步骤，你可以在Vue应用程序中检测用户的登录状态，并在用户尝试访问受保护页面时跳转到登录页面。同时，在用户登录和登出后，你可以根据需要跳转到相应的页面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值