• 数据结构之二叉搜索树(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;
                }
            }
            
  • 相关阅读:
    Node.js——fs常用API
    Node.js——Stream
    Node.js——Buffer
    Node.js——post方式提交的图片如何保存
    CSS——BFC
    Node.js——body方式提交数据
    Node.js——基本服务开启
    Node.js——url模块
    Node.js——render封装
    Node.js——开放静态资源原生写法
  • 原文地址:https://www.cnblogs.com/guojikun/p/9196167.html
Copyright © 2020-2023  润新知