精华内容
下载资源
问答
  • js二叉树数据结构实现,可帮助快速项目开发,nodejs调试
  • Javascript二叉树 结构 1、插入 2、查询 先序遍历 中、左、右 中序遍历 左、中、右 后序遍历 左、右、中 3、测试输出结果 4、代码 // 封装二次上搜索树 function BinarySerachTree() { function ...

    Javascript二叉树

    结构

    在这里插入图片描述

    • 1、插入
    • 2、查询
      先序遍历

    中、左、右

    在这里插入图片描述
    在这里插入图片描述

    中序遍历

    左、中、右

    在这里插入图片描述在这里插入图片描述

    后序遍历

    左、右、中

    在这里插入图片描述
    在这里插入图片描述

    3、测试输出结果
    4、代码

    
    // 封装二次上搜索树
    
    function BinarySerachTree() {
        function Node(key) {
            this.key = key;
            this.left = null;
            this.right = null;
        }
    
        // 属性
        this.root = null;
    
        // 插入方法
        BinarySerachTree.prototype.insert = function (key) {
    
            // 1、根据key创建节点
            let newNode = new Node(key);
    
            // 2、判断根节点是否有值
            if (this.root == null) {
                this.root = newNode;
            } else {
                this.insertNode(this.root, newNode)
            }
        }
        // 节点插入位置的判断方法
        BinarySerachTree.prototype.insertNode = function (node, newNode) {
    
            // 1、向左查找
            if (newNode.key < node.key) {
                if (node.left == null) {
                    node.left = newNode;
                } else {
                    this.insertNode(node.left, newNode)
                }
            } else {  // 2、向右查找
                if ((node.right == null)) {
                    node.right = newNode;
                } else {
                    this.insertNode(node.right, newNode)
                }
            }
        }
    
        // 树的遍历
        // 1、先序遍历
        BinarySerachTree.prototype.preOrderTraversal = function (handle) {
            this.preOrderTraversalNode(this.root, handle);
        }
    
        // 节点查找中间件函数(方法)
        BinarySerachTree.prototype.preOrderTraversalNode = function (node, handle) {
            if (node != null) {
                // 处理进过的节点
                handle(node.key) 
                
                // 处理经过的左子节点
                this.preOrderTraversalNode(node.left, handle);
    
                // 处理经过的右节点
                this.preOrderTraversalNode(node.right, handle);
            }
        }
    
        // 2、中序遍历
        BinarySerachTree.prototype.midOrderTraversal = function (handle) {
            this.midOrderTraversalNode(this.root, handle);
        }
    
        BinarySerachTree.prototype.midOrderTraversalNode = function (node, handle) {
            if(node != null) {
                this.midOrderTraversalNode(node.left, handle);
                handle(node.key)
                this.midOrderTraversalNode(node.right, handle);
            }
        }
    
        //  3、后序遍历
        BinarySerachTree.prototype.postOrderTraversal = function (handle) {
            this.postOrderTraversalNode(this.root, handle);
        }
    
        BinarySerachTree.prototype.postOrderTraversalNode = function(node, handle) {
            if(node != null ) {
                this.postOrderTraversalNode(node.left, handle);
                this.postOrderTraversalNode(node.right, handle)
                handle(node.key)
            }
        }
    }
    
    
    
    测试输出
    
    let bst = new BinarySerachTree()
    
    bst.insert(11);
    bst.insert(7);
    bst.insert(15);
    bst.insert(5);
    bst.insert(3);
    bst.insert(9);
    bst.insert(8);
    bst.insert(10);
    bst.insert(13);
    bst.insert(12);
    bst.insert(14);
    bst.insert(20);
    bst.insert(18);
    bst.insert(25);
    bst.insert(6);
    
    
    // 测试前序遍历
    let str_pre = '';
    bst.preOrderTraversal(function(key){
        str_pre += key + ', '
    })
    console.log(str_pre);
    
    // 测试中序遍历
    let str_mid = '';
    bst.midOrderTraversal( key => {
        str_mid+= key + ', '
    })
    console.log(str_mid);
    
    // 测试后序遍历
    let str_post = '';
    bst.postOrderTraversal( key => {
        str_post += key + ', '
    })
    console.log(str_post);
    

    输入结果

    先、中、后序遍历结果输出
    在这里插入图片描述
    数据结构

    展开全文
  • js代码-13.2 平衡二叉树构造
  • js实现二叉树 1. 掌握的知识 二叉树中对循环 while 和 递归使用的比较多,例如查找节点 //查找一个节点 serch(key){ if(this.root == null)return false; let current = this.root; while(current.key != key){...

    js实现二叉树

    在这里插入图片描述

    1. 掌握的知识

    二叉树中对循环 while 和 递归使用的比较多,例如查找节点

    //查找一个节点
      serch(key){
        if(this.root == null)return false;
        let current = this.root;
        while(current.key != key){
          if(key < current.key){
            current = current.left;
          }else{
            current = current.right;
          }
        }
        return current;
      }
    
    • 二叉树的遍历
    • 二叉树的查找
    • 二叉树的插入

    2. 二叉搜索树实现代码

    /* 二叉搜索树 */
    class BST {
    
      constructor() {
        //二叉搜索树的属性
        //只需要一个根节点 root
        this.root = null;
      }
      //创建节点
      createNode({key, val}) {
        return {
          left: null,
          key,
          val,
          right: null,
        };
      }
      //插入 需要传入这种格式的-{key,val}
      insert(data){
        //0. 创建节点
        let node = this.createNode(data);
        //1.判断root是否为空
        //1.1 空的话,直接插入
        if(this.root == null){
          //1.2 创建节点
          this.root = node;
          return;
        }
        //1.3 非空进入直接出入节点
        this.insertNode(this.root,node);
      }
      //插入节点处理函数
       insertNode(pNode,newNode){
        //2. 比较父节点的key和要插入节点的key,
        //2.1 如果小于父节点key, 进入下一步
        if(pNode.key > newNode.key){
          //3. 判断left 是否为空,为空直接插入
          if(pNode.left == null){
            pNode.left = newNode;
          }else{
            //3.1 不为空,继续比较left中的key 
            //3.2 如果left 中key 大于 传入的key
            //...一直循环并判断比较key,直到查询到 left或者 right为空的节点,然后插入
            this.insertNode(pNode.left,newNode);
          }
        }else{
          if(pNode.right == null){
            pNode.right = newNode;
          }else{
            //3.1 不为空,继续比较right中的key 
            //3.2 如果right 中key 大于 传入的key
            //...一直循环并判断比较key,直到查询到 right或者 right为空的节点,然后插入
            this.insertNode(pNode.right,newNode);
          }
        }
        
      }
      //先序遍历,如果要处理每个遍历的内容,需要传入一个回调函数
      preOrderTraverse(cb){
        //1.判断root是否为空
        //2.空直接返回
        if(this.root == null)return;
        //3.非空的话,遍历每一个node
        this.preOrderTraverseNode(this.root,cb);
      }
      //先序遍历node处理函数
      preOrderTraverseNode(node,cb){
        if(node != null){
          cb(node);
          this.preOrderTraverseNode(node.left,cb);
          this.preOrderTraverseNode(node.right,cb);
        }
      }
      //中序遍历
      inOrderTraverse(){
        if(this.root == null)return;
        this.inOrderTraverseNode();
      }
      inOrderTraverseNode(node=this.root){
        if(node != null){
          this.inOrderTraverseNode(this.left);
          console.log(node);
          this.inOrderTraverseNode(this.right);
        }
      }
      //后序遍历
      postOrderTraverse(){
        if(this.root == null)return;
        this.postOrderTraverseNode();
      }
      postOrderTraverseNode(node=this.root){
        if(node != null){
          this.postOrderTraverseNode(this.left);
          this.postOrderTraverseNode(this.right);
          console.log(node);
        }
      }
      //获取最大值
      max(){
        if(this.root ==null)return null;
        return this.getMaxNode(this.root);
      }
      getMaxNode(node){
        if( node.right == null ){
          return node;
        }else{
         return this.getMaxNode(node.right);
        }
      }
      min(){
        if(this.root == null)return null;
        let current = this.root;
        while(current.left != null){
          current = current.left;
        }
        return current;
    
      }
      //查找一个节点
      serch(key){
        if(this.root == null)return false;
        let current = this.root;
        while(current.key != key){
          if(key < current.key){
            current = current.left;
          }else{
            current = current.right;
          }
        }
        return current;
      }
      
    }
    let bst = new BST();
    bst.insert({key:11,val:3});
    bst.insert({key:15,val:333});
    bst.insert({key:7,val:3});
    bst.insert({key:5,val:3});
    bst.insert({key:3,val:3});
    bst.insert({key:333,val:311111});
    bst.insert({key:9,val:3});
    bst.insert({key:8,val:3});
    bst.insert({key:1,val:555});
    /* bst.preOrderTraverse(function(node){
      console.log(node.val);
    }); */
    console.log(bst.serch(5));
    

    3.二叉树的缺点

    • 如果插入的数字是连续的,会导致二叉树变成非平衡二叉树,严重影响性能

    可以使用红黑树来解决这个问题

    展开全文
  • js二叉树

    2021-04-20 18:21:17
    二叉树的每个节点最多有两个子节点的树结构 根结点: 一棵树最上面的节点称之为根结点 父节点,字节点: 如果一个下面连接多个子节点,那么这个节点就是父节点,下面的节点称之为子节点 满二叉树: 一棵二叉树的...

    二叉树:

    二叉树的每个节点最多有两个子节点的树结构
    

    根结点:

    一棵树最上面的节点称之为根结点

    父节点,字节点:

    如果一个下面连接多个子节点,那么这个节点就是父节点,下面的节点称之为子节点

    满二叉树:

    一棵二叉树的结点要么是叶子结点,要么它有两个子结点(如果一个二叉树的层数为K,且结点总数是(2^k) -1,则它就是满二叉树。)

    完全二叉树:

    若设二叉树的深度为k,除第 k 层外,其它各层 (1~k-1) 的结点数都达到最大个数,第k 层所有的结点都连续集中在最左边,这就是完全二叉树。

    平衡二叉树:

    它或者是一颗空树,或它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1,且它的左子树和右子树都是一颗平衡二叉树。
    实现代码

    class Tree {
      constructor(key) {
          this.key = key
          this.left = null
          this.right = null
      }
    }
    
    class BinarySearchTree {
      constructor(key) {
          this.root = null
          this.keys = key
      }
      // 创建二叉树 
      insertNode(root, newTree) {
          if (newTree.key < root.key) {
              if (root.left === null) {
                  root.left = newTree
              } else {
                  this.insertNode(root.left, newTree)
              }
          } else {
              if (root.right === null) {
                  root.right = newTree
              } else {
                  this.insertNode(root.right, newTree)
              }
          }
      }
      sortTree() {
          this.keys.forEach(ele => {
              let a = new Tree(ele)
              if (this.root === null) {
                  this.root = a
              } else {
                  this.insertNode(this.root, a)
              }
          });
          return this.root
      }
      //中序遍历的递归定义:先左子树,后根节点,再右子树
      inOrderTraverseFunction(node, cb) {
          // console.log(node,'aaaa')
          if (node !== null) {
              this.inOrderTraverseFunction(node.left, cb)
              cb(node.key)
              this.inOrderTraverseFunction(node.right, cb)
          }
      }
      // 前序遍历的递归定义:先根节点,后左子树,再右子树
      preOrderTraverseFunction(node, cb) {
          if (node !== null) {
              cb(node.key)
              this.preOrderTraverseFunction(node.left, cb)
              this.preOrderTraverseFunction(node.right, cb)
          }
      }
      //后序遍历的递归定义:先左子树,后右子树,再根节点
      postOrderTraverseFunction = (node, cb) => {
          if (node !== null) {
              this.postOrderTraverseFunction(node.left, cb)
              this.postOrderTraverseFunction(node.right, cb)
              cb(node.key)
          }
      }
      // 寻找最小值  寻找二叉树左子树最左侧那个没有子节点的树
      minNode(node) {
          if (node) {
              while (node && node.left !== null) {
                  node = node.left
              }
              console.log(node.key)
              return node.key
          }
          return null
      }
      // 寻找最大值 寻找二叉树右子树最右侧没有子节点的树
      maxNode(node) {
          if (node) {
              while (node && node.right !== null) {
                  node = node.right
              }
              console.log(node.key)
              return node.key
          }
          return null
      }
    
      // 寻找某个值
      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
          }
      }
      // 删除某个叶子节点
      removeNode(node, key) {
          if (node === null) {
              return null
          }
          if (key < node.key) {
              node.left = this.removeNode(node.left, key)
              return node
          } else if (key > node.key) {
              node.right = this.removeNode(node.right, key)
              return node
          } else {
              if (node.left === null && node.right === null) {
                  node = null
                  return node
              }
          }
      }
    }
    let callback = (key) => {
      console.log(key)
    }
    
    展开全文
  • 二叉树(Binary Search Tree),或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的...

    二叉树Binary Search Tree),或者是一棵空树,或者是具有下列性质的二叉树

    1. 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值;
    2. 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值;
    3. 它的左、右子树也分别为二叉排序树。

    代码实现如下:

    function Node()
    {
      this.left=null;
      this.right=null;
      this.value=null;
    }
    
    Node.prototype.add=function(value)//子节点的增加
    {
    
       
       if(value!=null && typeof value != 'undefined')
       {
           if(this.value==null)
    	   {
    		   this.value=value;
    		   return ;
    	   }
    	   
    	   var node=new Node();
           node.value=value;
    	   if(this.value >= value)// on left
    	   {	   
    	      if(this.left==null)
    		  {
    		     this.left=node;
    		  }
    		  else
    		  {
    		     this.left.add(value);
    		  }
    	   }
    	   else                    // on right
    	   {
    	      if(this.right==null)
    		  {
    		     this.right=node;
    		  }
    		  else
    		  {
    		    this.right.add(value);
    		  }
    	   }
       }
    }
    
    Node.prototype.print=function(data)//打印排序数组
    {
       //if((typeof data == 'undefined') || !(data instanceof Array) )return;
       if(this.left!=null)
       {
         this.left.print(data);
       }   
       data.push(this.value);
       if(this.right!=null)
       {
          this.right.print(data);  
       }   
    }
    
    function app() 
    {
      var data=[2,6,56,102,5,4,47,7000,200,45,24,85,63,954,6222,5] ; 
      var root=new Node();
      //以下构造二叉树
      for(var i=0;i<data.length;i++)
      {
         root.add(data[i]);
      }
      
      var rs=[];
      root.print(rs);  
      alert(rs.join(","));
      
    }

     

    展开全文
  • JS二叉树

    2017-11-02 01:51:50
    生成一棵二叉树二叉树实现原理 把第一位当做根节点,比根节点小的数放在左子树上,比根节点大的数放到右子树上,以此类推。...结构如下 生成的二叉树对象如下 let tree = { key: 8, left: { key: 3, left...
  • JavaScript二叉树遍历

    2018-03-21 11:15:59
    本文主要讲述二叉树的先序、中序、后序递归遍历及非递归遍历,并讲述如何使用JavaScript实现遍历逻辑。 下面,我们通过一个例子来回顾一下先序、中序、后序遍历: 上面二叉树先序、中序、后序遍历结果分别为:...
  • <!DOCTYPE html> <title>Title function Node(element,left,right){ this.element=element; this.left=left; this.right=right; this.show=function (data) { } } function BST() { ...二叉树
  • js二叉树实现

    千次阅读 2019-03-04 14:17:26
    1 .简介 如上图所示: “8”为root节点(根节点),“3”和“10”分别为“8” 的左子节点(左子树)...“3”的左子树“1”小于“3”,右子树“5”大于“3”,形如这种的二叉树称为排序二叉树。 2 .代码实现 &amp;lt...
  • //二叉搜索树结构(BST) function BinarySearchTree(){ //每一个节点的数据结构 function Node(key){ this.key = key; this.left = null; this.right = null; } this.root = null; //向树中插入...
  • 主要介绍了JavaScript数据结构与算法之二叉树插入节点、生成二叉树,结合实例形式较为详细的分析了javascript二叉树相关概念、定义、节点插入、遍历输出等相关操作技巧,需要的朋友可以参考下
  • JS 二叉树基本操作

    2020-08-01 17:18:00
    二叉树的翻转 function reverseTree(root) { if (root !== null) { [root.left, root.right] = [root.right, root.left] reverseTree(root.left) reverseTree(root.right) } } 判断二叉树是否完全对称 ...
  • 使用js进行二叉树结构数据与数组结构数据的互相转化
  • JavaScript二叉树

    2009-03-19 16:41:00
    JavaScript中使用数组对象实现二叉树的深度与广度搜索。var t = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19];//下面这段深度优先搜索方法出自Aimingoo的【JavaScript语言精髓与编程实践】var deepView =...
  • 主要介绍了JavaScript数据结构之二叉树的计数算法,结合具体实例形式分析了javascript二叉树记录更新次数的原理与操作技巧,需要的朋友可以参考下
  • 最近关注了下扫描线算法,有涉及二叉树的地方,故找了点资料,用js实现了部分功能。 关于二叉树 偷懒直接链接 维基百科 | 百度百科 完整实现代码 (function (w) { // 树总集 let rootTree; const binaryTree =...
  • js二叉树的实现练手

    2017-12-09 16:29:18
    js二叉树的实现练手二叉树的好处就不用说了,本实例主要实现了排序、查找、删除、新增,有兴趣的同学可以继续完善。<!DOCTYPE html> <title>js二叉树 <script type="text/javascript"> /* ===yancheng@infog
  • 主要介绍了JavaScript数据结构二叉树的查找算法,结合具体实例形式分析了javascript针对二叉树节点最小值、最大值的相关查找操作实现技巧,需要的朋友可以参考下
  • 主要介绍了JavaScript数据结构二叉树的遍历算法,简单介绍了javascript实现数据结构二叉树的中序遍历、先序遍历及后序遍历方法与相关使用技巧,需要的朋友可以参考下
  • 主要介绍了JavaScript数据结构二叉树的删除算法,简单分析了javascript删除数据结构二叉树节点时所遇到的各种情况与相关的处理原理与算法实现技巧,需要的朋友可以参考下
  • 主要介绍了JavaScript数据结构和算法之二叉树详解,本文讲解了二叉树的概念、二叉树的特点、二叉树节点的定义、查找最大和最小值等内容,需要的朋友可以参考下
  • 二叉树的定义、特定; 二叉树的前序遍历、中序遍历、后序遍历、层序遍历; 二叉树的设计与实现;
  • 概念 二叉树是树中每个节点最多只能...在JavaScript中常用Object来实现二叉树,如上图二叉树可表示为: const bt = { val: 1, left: { val: 2, left: { val: 4, left: null, right: null }, right: { val: 5,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,801
精华内容 5,120
关键字:

js二叉树结构