数据结构之二叉搜索树(BST)--JavaScript实现

简介: 数据结构之二叉搜索树(BST)--JavaScript实现

原理:

叉排序树的查找过程和次优二叉树类似,通常采取二叉链表作为二叉排序树存储结构中序遍历二叉排序树可得到一个关键字的有序序列,一个无序序列可以通过构造一棵二叉排序树变成一个有序序列,构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点,在进行插入操作时,不必移动其它结点,只需改动某个结点的指针,由空变为非空即可。搜索,插入,删除的复杂度等于树高,O(log(n)).

JavaScript实现:

var BinarySearchTree = function(){
            this.root = null;
        }
        BinarySearchTree.prototype = {
            insert: function(key){//插入
                var newNode = new this.Node(key);
                if(this.root === null){
                    this.root = newNode;
                }else{
                    this.insertNode(this.root, newNode)
                }
                console.log(this.root)
            },
            inOrderTraverse: function(callback){//中序查找
                this.inOrderTraverseNode(this.root, callback);
            },
            preOrderTraverse: function(callback){//先序查找
                this.preOrderTraverseNode(this.root, callback);
            },
            postOrderTraverse: function(callback){//后序查找
                this.postOrderTraverseNode(this.root, callback);
            },
            min: function(){//最小值
                return this.minNode(this.root)
            },
            max: function(){//最大值
                return this.maxNode(this.root)
            },
            search: function(key){//查找
                this.searchNode(this.root, key)
            },
            remove: function(key){//移除树节点
                this.removeNode(this.root, key)
            },
            Node: function(key){
                this.key = key;
                this.left = null;
                this.right = null;
            },
            insertNode: function(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)
                    }
                }
            },
            inOrderTraverseNode: function(node, callback){
                if(node !== null){
                    this.inOrderTraverseNode(node.left, callback);
                    callback(node.key);
                    this.inOrderTraverseNode(node.right, callback);
                }
            },
            preOrderTraverseNode: function(node, callback){
                if(node !== null){
                    callback(node.key);
                    this.preOrderTraverseNode(node.left, callback);
                    this.preOrderTraverseNode(node.right, callback);
                }
            },
            postOrderTraverseNode: function(node, callback){
                if(node !== null){
                    this.postOrderTraverseNode(node.left, callback);
                    this.postOrderTraverseNode(node.right, callback);
                    callback(node.key);
                }
            },
            minNode: function(node){
                if(node){
                    while(node && node.left !== null){
                        node = node.left;
                    }
                    return node.key;
                }
                return null;
            },
            maxNode: function(node){
                if(node){
                    while(node && node.right !== null){
                        node = node.right;
                    }
                    return node.key;
                }
                return null;
            },
            searchNode: function(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;
                    }else if(node.left === null){
                        node = node.right;
                        return node;
                    }else if(node.right === null){
                        node = node.left;
                        return node;
                    }
                    var aux = this.findMinNode(node.right);
                    node.key = aux.key;
                    node.right = this.removeNode(node.right, aux.key);
                    return node;
                }
            },
            findMinNode: function(node){
                if(node){
                    while(node && node.left !== null){
                        node = node.left;
                    }
                    return node.key;
                }
                return null;
            }
        }

相关文章
|
5月前
|
存储 监控 算法
公司内部网络监控中的二叉搜索树算法:基于 Node.js 的实时设备状态管理
在数字化办公生态系统中,公司内部网络监控已成为企业信息安全管理体系的核心构成要素。随着局域网内终端设备数量呈指数级增长,实现设备状态的实时追踪与异常节点的快速定位,已成为亟待解决的关键技术难题。传统线性数据结构在处理动态更新的设备信息时,存在检索效率低下的固有缺陷;而树形数据结构因其天然的分层特性与高效的检索机制,逐渐成为网络监控领域的研究热点。本文以二叉搜索树(Binary Search Tree, BST)作为研究对象,系统探讨其在公司内部网络监控场景中的应用机制,并基于 Node.js 平台构建一套具备实时更新与快速查询功能的设备状态管理算法框架。
181 3
|
7月前
|
算法 Java
算法系列之数据结构-二叉搜索树
二叉查找树(Binary Search Tree,简称BST)是一种常用的数据结构,它能够高效地进行查找、插入和删除操作。二叉查找树的特点是,对于树中的每个节点,其左子树中的所有节点都小于该节点,而右子树中的所有节点都大于该节点。
229 22
|
7月前
|
C语言 C++ 容器
【数据结构】二叉搜索树(二叉排序树)
本文介绍了二叉搜索树(Binary Search Tree, BST)的定义、实现及其性能分析。二叉搜索树是一种特殊的二叉树,其特点是左子树所有节点值小于根节点值,右子树所有节点值大于根节点值,且每个子树也满足此特性。文中详细讲解了BST的节点结构、插入、查找、删除等操作的实现,并通过C++代码展示了这些功能。此外,还讨论了BST的性能:在理想情况下,时间复杂度接近O(logN),但在最坏情况下可能退化为O(N)。为了提高效率,后续将学习自平衡二叉搜索树如AVL树和红黑树。掌握BST有助于理解STL中的set和map容器。感谢阅读,欢迎点赞支持。
531 9
|
存储 Java Serverless
【数据结构】哈希表&二叉搜索树详解
本文详细介绍了二叉搜索树和哈希表这两种数据结构。二叉搜索树是一种特殊二叉树,具有左子树节点值小于根节点、右子树节点值大于根节点的特点,并且不允许键值重复。文章给出了插入、删除和搜索等方法的具体实现。哈希表则通过哈希函数将键名映射为数组下标,实现快速查找,其插入、删除和查找操作时间复杂度理想情况下为O(1)。文中还讨论了哈希函数的设计原则、哈希冲突的解决方法及哈希表的实现细节。
261 8
【数据结构】哈希表&二叉搜索树详解
|
存储 算法 数据管理
数据结构与算法学习二零:二叉排序树(BST)、平衡二叉树(AVL)
这篇文章通过需求分析、代码实现和测试验证,详细介绍了二叉排序树的创建、遍历和删除操作,以及二叉平衡树(AVL)的自平衡特性和单旋转操作,旨在提高树结构在数据管理中的效率和性能。
284 0
数据结构与算法学习二零:二叉排序树(BST)、平衡二叉树(AVL)
|
存储
【高阶数据结构】深度探索二叉树进阶:二叉搜索树概念及其高效实现(二)
【高阶数据结构】深度探索二叉树进阶:二叉搜索树概念及其高效实现
【高阶数据结构】深度探索二叉树进阶:二叉搜索树概念及其高效实现(三)
【高阶数据结构】深度探索二叉树进阶:二叉搜索树概念及其高效实现
【高阶数据结构】深度探索二叉树进阶:二叉搜索树概念及其高效实现(一)
【高阶数据结构】深度探索二叉树进阶:二叉搜索树概念及其高效实现
【数据结构】二叉搜索树的功能实现详解
【数据结构】二叉搜索树的功能实现详解
109 0
【数据结构】AVL树——平衡二叉搜索树
【数据结构】AVL树——平衡二叉搜索树

热门文章

最新文章