js二叉树的实现练手

最新推荐文章于 2023-06-26 14:20:22 发布
最新推荐文章于 2023-06-26 14:20:22 发布
阅读量725 收藏 1
点赞数 2
分类专栏： js 二叉树 算法 文章标签： 二叉树 实例 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuewufeifang/article/details/78759958
版权
js 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
二叉树
1 篇文章 0 订阅
订阅专栏
算法
1 篇文章 0 订阅
订阅专栏

js二叉树的实现练手

二叉树的好处就不用说了，本实例主要实现了排序、查找、删除、新增，有兴趣的同学可以继续完善。

<!DOCTYPE html>
<html>
<head>
    <title>js二叉树</title>
</head>
<body>
    <script type="text/javascript">
        /*
            ===yancheng@infogo.com.cn======

            主要实现：二叉树排序、查找、删除、新增
            原始数据：[8,4,1,6,5,7,15,14,13,16]
            二叉树结构：左小右大方式
                            8                   ----第一层
                4                       15      ----第二层
            1       6               14      16  ----第三层
                5       7       13              ----第四层

            二叉树满足条件：
                （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
                （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
                （3）左、右子树也分别为二叉排序树；
                （4）没有键值相等的节点。

        */

        //二进制树
        function binaryTree(valarr){
            var rootNode = null;
            //创建节点对象方法
            function nodeTree(val){
                this.val = val;
                this.left = null;
                this.right = null;
            }

            //设置节点
            var setNode = function(node,val){
                var newNode = new nodeTree(val);
                if(rootNode===null){
                    rootNode = newNode;
                }else if(val<node.val){
                    if(node.left!==null){
                        setNode(node.left, val);
                    }else{
                        node.left = newNode;
                    }
                }else if(val>node.val){
                    if(node.right!==null){
                        setNode(node.right, val);
                    }else{
                        node.right = newNode;
                    }
                }
            }
            //根据值返回节点
            var getNode = function(val){
                var searchval = parseFloat(val);
                if(rootNode!==null && searchval){   
                    return (function fn(node, searchval){

                            if(searchval == node.val){
                                return node;
                            }else if(searchval<node.val && node.left!==null){
                                return fn(node.left, searchval);
                            }else if(searchval>node.val && node.right!==null){
                                return fn(node.right, searchval);
                            }else{
                                return false;
                            }

                    })(rootNode, searchval)
                }
                return false;
            }
            //获取最小节点
            var getMinNode = function(node){
                if(node!==null){
                    return (function fn(node){
                        if(node.left!==null){
                            return fn(node.left);                           
                        }
                        return node;
                    })(node)
                }
                return null;
            }

            //前序遍历
            this.preorderTraversal = function(){
                if(rootNode!==null){
                    var orderBefer = [];
                    return (function fn(node){
                        if(node!==null){
                            orderBefer.push(node.val);
                            fn(node.left);
                            fn(node.right);
                            return orderBefer;
                        }
                    })(rootNode)
                }
                return null;
            }

            //中序遍历
            this.inorderTraversal = function(){
                if(rootNode!==null){
                    var orderBefer = [];
                    return (function fn(node){
                        if(node!==null){
                            fn(node.left);
                            orderBefer.push(node.val);
                            fn(node.right);
                            return orderBefer;
                        }
                    })(rootNode)
                }
                return null;
            }

            //后续遍历
            this.postorderTraversal  = function(){
                if(rootNode!==null){
                    var orderBefer = [];
                    return (function fn(node){
                        if(node!==null){
                            fn(node.right);
                            orderBefer.push(node.val);
                            fn(node.left);
                            return orderBefer;
                        }
                    })(rootNode)
                }
                return null;
            }
            //获取最大值
            this.getMaxVal = function(){
                if(rootNode!==null){
                    return (function fn(node){
                        if(node.right!==null){
                            return fn(node.right);                          
                        }
                        return node.val;
                    })(rootNode)
                }
                return null;
            }
            //获取最小值
            this.getMinVal = function(){
                if(rootNode!==null){
                    var minNode = getMinNode(rootNode);
                    if(minNode!=null){
                        return minNode.val;
                    }
                }
                return null;
            }

            //查找某值是否存在
            this.searcheVal = function(val){
                var node = getNode(val);
                return typeof node == 'object' ? true :false;
            }

            //删除某个值
            this.removeVal = function(val){
                var searchval = parseFloat(val);
                if(rootNode!==null && searchval){
                    return (function fn(node, val){
                        if(node===null){return null;}

                        if(val < node.val){
                            node.left = fn(node.left, val);
                            return node;
                        }else if(val > node.val){
                            node.right = fn(node.right, val);
                            return node;
                        }else{//找到

                            if(node.left!=null && node.right==null){
                                node = node.left;
                                return node;
                            }else if(node.left==null && node.right!=null){
                                node = node.right
                                return node;
                            }else if(node.left!=null && node.right!=null){
                                //如果是中间节点且有左右子树，则查找右边最小节点，替换当前节点
                                var rightMinNode = getMinNode(node.right);
                                node.val = rightMinNode.val;
                                node.right = fn(node.right, rightMinNode.val);
                                return node;
                            }else{
                                node = null;
                                return node;
                            }
                        }

                    })(rootNode, val);
                }
                return false;

            }

            //添加值
            this.insertVal = function(val){
                setNode(rootNode,val);
            }

            //初始化数据
            return (function(_this){
                for (var i = 0; i < valarr.length; i++) {
                    setNode(rootNode, valarr[i]);
                }
                return _this;
            })(this);

        }

        //启动
        var BT = new binaryTree([8,4,1,6,5,7,15,14,13,16]);
        console.log(BT);
        var predata = BT.preorderTraversal();
            console.log('前序：', predata);
        var indata = BT.inorderTraversal();
            console.log('中序：', indata);
        var postdata = BT.postorderTraversal();
            console.log('后序：', postdata);
        var isSearch = BT.searcheVal(5);
            console.log('搜索5：', isSearch);
        var minVal = BT.getMinVal();
            console.log('最小值：', minVal);
        var maxVal = BT.getMaxVal();
            console.log('最大值：', maxVal);
        var removeVal = BT.removeVal(8);
            console.log('删除8后 前序：', BT.preorderTraversal());
        var insertdata = BT.insertVal(9);
            console.log('插入9 前序：', BT.preorderTraversal());

    </script>
</body>
</html>

简单测试过，欢迎吐槽。

xuewufeifang
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javascript实现二叉树的代码
10-19
在本文中，我们将深入探讨如何使用JavaScript实现二叉搜索树（Binary Search Tree，简称BST）。二叉搜索树是一种特殊的二叉树，它的每个节点都遵循特定的规则：左子节点的值小于父节点的值，而右子节点的值大于或...
二叉树（js实现）
03-10 5932
二叉树基本概念基本术语二叉树类型性质遍历代码实现(js)前序遍历中序遍历后序遍历层序遍历二叉搜索树镜像二叉树重建二叉树其他常见算法题求二叉树深度二叉树结点总数判断二叉树子结构将二叉搜索树转换成一个排序的双向链表 基本概念 二叉树是n个有限元素的集合，该集合或者为空、或由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成 基本术语 结点之间的关系 若一个结点有子树，那么该结点称为子树根的双亲，子树的根称为该结点的孩子 有相同双亲的结点互为兄弟 一个结点的所有子树上的任何
使用js实现二叉树
w1787184616的博客
07-19 2353
树是计算机科学中经常用到的一种数据结构。树是一种非线性的数据结构，以分层的方式存储数据。树被用来存储具有层级关系的数据，比如文件系统中的文件；树还被用来存储有序列表。从本篇开始，将会实现一种特殊的树——二叉树。 二叉树具有诸多优点。相对于链表来说，二叉树在进行查找时速度非常快，而相对于数组来说，为二叉树添加或删除元素也非常快。...
js实现二叉树
ssjjrr的博客
02-02 557
js实现二叉树
十道二叉树面试题，对二叉树理解更进一步
weixin_46016019的博客
05-06 3100
学习二叉树有一个很重要的思想就是分治（将一个大问题划分为最小规模的子问题），常用方法之一就是递归，而递归是很抽象的，当对递归过程不理解时，建议多画图将递归过程实例化，拒绝人脑压栈...
数据结构 - JS实现二叉树
ngd-b的博客
05-30 3252
二叉树的定义、特定； 二叉树的前序遍历、中序遍历、后序遍历、层序遍历； 二叉树的设计与实现；
JS二叉树的简单实现方法示例
10-20
JavaScript实现二叉树涉及的概念主要包括了二叉树的定义、遍历、插入、删除、查找、排序等基本操作。在实际编程中，通过定义一个节点类（Node）以及一个二叉搜索树类（BST）来实现这些操作。 首先，定义一个节点类...
js实现搜索二叉树.rar
06-08
以上就是使用JavaScript实现二叉树的基本操作，包括创建、遍历和删除节点。理解并熟练运用这些概念对于提升JavaScript编程能力和解决复杂问题的能力非常有帮助。通过不断练习和实践，你将能够更好地掌握这些技能。
javascript实现二叉树遍历的代码
10-19
在本文中，我们将深入探讨JavaScript实现二叉树遍历的方法。首先，二叉树是一种数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。我们通过创建一个`Node`构造函数和一个`BST`（二叉搜索树）...
JS实现的二叉树算法完整实例
10-20
在JavaScript（JS）中，二叉树是一种数据结构，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在这个完整的实例中，我们将深入理解如何用JS来定义、创建和操作二叉树。 首先，我们定义了一...
Js实现二叉树
xiayngbaidu12345的博客
03-26 1800
Js实现二叉树1.二叉树特性2.二叉搜索树（BST）2-1.向树中插入一个新的键 1.二叉树特性 一个二叉树第i层最多的节点数为2^(i-1),i>=1; 深度==层数； 深度为k的二叉树最多的节点数为2^k-1,k>=1; 对于任何非空的二叉树T，若n0表示叶节点的个数，n2表示度为2的非叶节点的个数，则有n0=n2+1. 2.二叉搜索树（BST） 二叉搜索树是一颗二叉树，可以是空； 如果不为空：         非空左子树的所有键值小于其根节点的
二叉树的遍历 js实现
qq_52046856的博客
04-13 1518
二叉树主要有两种遍历方式：一是深度优先遍历，即先往二叉树底部走，遇到叶子节点再返回；二是广度优先遍历，即对二叉树的每一层逐层遍历节点。
JavaScript二叉树及各种遍历算法详情
最新发布
百创科技
06-26 602
二叉树是每个节点最多只能有两个子节点的树，如下图所示：第i层的节点最有只有2^(i-1)个；如果这颗二叉树的深度为k，那二叉树最多有2^k-1个节点；在一个非空的二叉树中，若使用n0表示叶子节点的个数，n2是度为2的非叶子节点的个数，那么两者满足关系。
JS实现二叉树的创建和遍历
11-06 286
1、先说二叉树的遍历，遍历方式： 　　　前序遍历：先遍历根结点，然后左子树，再右子树 　　　中序遍历：先遍历左子树，然后根结点，再右子树 　　　后续遍历：先遍历左子树，然后右子树，再根结点 上代码：主要还是利用递归 function TreeCode() { let BiTree = function (ele) { this.data ...
二叉树--经典面试题1
xaiobit_hl的博客
05-27 1156
目录 1.检查两棵树是否相同 2.另一棵树的子树 3.判断一棵二叉树是否是平衡二叉树 4.对称二叉树
javascript算法系列——树：二叉树（1）
weixin_43867717的博客
03-07 703
二叉树 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。 1.定义 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 简单理解就是：二叉树的每个子节点都只有
js数据结构和算法（三）二叉树
01-04 295
二叉树的概念 二叉树（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者为空集（空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 二叉树的特点 每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。二叉树中每一个节点都是一个对象，每一个数据节点都有三个指针，分别是指向父母、左孩子和右孩子的指针。每一个节点都是通过指针相互连接
js手写二叉排序树
qq593249106的博客
10-21 433
前端面试题之手写二叉排序树 二叉排序树:每个节点的左节点都比根节点小，右节点都比根节点大 function TreeNode(data, left, right) { //节点结构 this.val = data; this.left = left; this.right = right; } function BST() { //二叉树构造函数 this.roo...
js手写二叉搜索树
qq_45305088的博客
06-04 322
function BinarySearchTree() { this.root = null; function Node(key) { this.key = key; this.left = null; this.right = null; } //插入节点 BinarySearchTree.prototype.insert = function (key) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值