JS-常用的数据结构之树、二叉树、平衡二叉树

二叉树的实现代码

// 二叉树构造
function BinaryTree(){
    var Node=function(key){         //节点函数
        this.key=key;
        this.left=null;
        this.right=null;
    }

    var root = null;
    this.insert = function(key){
        var newNode = new Node(key);
        if(root == null){
            root = newNode;
        }else{
            insertNode(root, newNode);
        }
    }

    var insertNode = function(node, newNode){
        if(node.key > newNode.key){
            if(node.left == null){
                node.left = newNode;
            }else{
                insertNode(node.left, newNode);
            }
        }else{
            if(node.right == null){
                node.right = newNode;
            }else{
                insertNode(node.right, newNode);
            }
        }
    }

    var inOrderTraverseNode = function(node, callback){
        if(node != null){
            inOrderTraverseNode(node.left, callback);
            callback(node.key);
            inOrderTraverseNode(node.right, callback);
        }
    }
    // 中序遍历 
    this.inOrderTraverse = function(callback){
        inOrderTraverseNode(root, callback);
    }

    var proOrderTraverseNode=function(node,callback){
        if(node!=null){
            callback(node.key)
            proOrderTraverseNode(node.left,callback)
            proOrderTraverseNode(node.right,callback)
        }
    }
    //前序遍历  复制   效率高得多
    this.proOrderTraverse=function(callback){
        proOrderTraverseNode(root,callback);
    }

    var postOrderTraverseNode=function(node,callback){
        if(node!=null){
            postOrderTraverseNode(node.left,callback)
            postOrderTraverseNode(node.right,callback)
            callback(node.key)
        }
    }
    //后续遍历  文件系统遍历
    this.postOrderTraverse=function(callback){
        postOrderTraverseNode(root,callback);
    }

    // 查找
    // 查找最大值
    var maxNode=function(node){
        if(node){
            while(node&&node.right!=null){
                node=node.right;
            }
            return node.key;
        }
    }
    this.max=function(){
        return maxNode(root);
    }

    // 查找最小值
    var minNode = function(node){
        if (node){
            while(node && node.left != null){
                node = node.left;
            }
            return node.key;
        }
    }    
    this.min=function(){
        return minNode(root);
    }

    // 查找指定值
    var searchNode=function(node,key){
        if (node == null){
            return false;
        }

        if(node.key > key){
            searchNode(node.left, key);
        }else if (node.key < key){
            searchNode(node.right, key);
        }else{
            return true;
        }
    }
    this.search=function(key){
        return searchNode(root,key)
    }

   /**
    * 二叉树的删除
    * 二叉树删除分三种情况
    * 删除左叶子节点
    * 删除右叶子节点
    * 以及拥有左右两个节点的主节点删除
    * 拥有左右两个节点的主节点删除要考虑到数据的可排序行需要将删掉的节点重新赋值
    */
   var findMinNode=function(node){ //如果存在左右两个节点的话查找右节点的最小节点
        if(node){
            while(node&&node.left!=null){
                node=node.left
            }
            return node;
        }
        return null
    }

   var removeNode=function(node,key){
       if (node == null){
            return null;
       }

       if(node.key > key){ // 递归查找左叶子节点，直接等于返回的null值
            node.left = removeNode(node.left, key);
            return node;
       }else if(node.key < key){
            node.right = removeNode(node.right, key);
            return node;
       }else{
            if(node.left==null&&node.right==null){// 当只有一个节点，而且被选中
                node=null;
                return node;
            }
            if(node.left==null){ //左节点为空
                node=node.right;
                return node;            
            }else if(node.right==null){//右节点为空
                node=node.left;
                return node;
            }
            
            // ?????
            var aux=findMinNode(node.right);//查找到右节点最小节点赋值
            node.key=aux.key;
            node.right=removeNode(node.right,aux.key);
            return node;
       }
   }
   this.remove=function(key){
        return removeNode(root,key)
    }
}

// test
var nodes=[8,3,10,2,9,14,4,7,13];
var binaryTree=new BinaryTree();
nodes.forEach(function(key){
    binaryTree.insert(key);
})
var callback=function(key){
    document.write(key);
}
binaryTree.inOrderTraverse(callback);

document.write("+++++++++" + binaryTree.max());