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

原理：

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

JavaScript实现：

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