js树的操作

树（有序的二叉树）

不多说直接上代码
第一部分是基本的工具类
这里创建了个比较的方法，方便使用
还创建了树的节点类

const Compare = {  //比较得静态变量
    LESS_THAN:-1,
    BIGGER_THAN:1,
    EQUAL_THAN:0,
}
function defaultCompareFn(a,b){  //此函数为比较函数
    if(a==b) return Compare.EQUAL_THAN;
    return a>b?Compare.BIGGER_THAN:Compare.LESS_THAN;
}
class TreeNode{//树得节点类
    constructor(key){
        this.key = key;
        this.left = null;
        this.right = null;
    }
}

第二部分开始写树的基本方法
这个类是先把比较方法放入构造函数中然后将节点的数据放入其中进行一系列的操作。

class BinarySearchThree{
    constructor(compareFn = defaultCompareFn){
        this.compareFn = compareFn; //将比较函数放入构造函数中方便调用
        this.root = null;
    }
    insert(key){//树插入
        if(this.root === null){
            this.root = new TreeNode(key);
        }else{
            this.insertNode(this.root,key);//这里进行判断所以咱们写了一个插入的辅助函数
        }
    }
    insertNode(root,key){ //插入得辅助函数
    //先进行比较要是小于根节点就放在左面的节点上要是大于就放在右面的节点上
        if(this.compareFn(root.key,key) === Compare.LESS_THAN){
            if(root.right === null) {
                root.right = new TreeNode(key);
            }else{
                this.insertNode(root.right,key)
            }
        }else{
            if(root.left === null) {
                root.left = new TreeNode(key);
            }else{
                this.insertNode(root.left,key)
            }
        }
    }
    //遍历这里用到了递归进行中序遍历使用回调函数的方式
    inOrderTravers(callback){//中序遍历
        this.inOrderTraversNode(this.root,callback)
    }
    inOrderTraversNode(node,callback){//中序遍历辅助函数
        if(node != null){
            this.inOrderTraversNode(node.left,callback);
            callback(node.key);
            this.inOrderTraversNode(node.right,callback);
        }
    }
    preOrderTravers(callback){//先序遍历
        this.preOrderTraversNode(this.root,callback)
    }
    preOrderTraversNode(node,callback){//先序遍历辅助函数
        if(node != null){
            callback(node.key);
            this.preOrderTraversNode(node.left,callback);
            this.preOrderTraversNode(node.right,callback);
        }
    }
    postOrderTravers(callback){//后序遍历
        this.postOrderTraversNode(this.root,callback)
    }
    postOrderTraversNode(node,callback){//后序遍历辅助函数
        if(node != null){
            this.postOrderTraversNode(node.left,callback);
            this.postOrderTraversNode(node.right,callback);
            callback(node.key);
        }
    }
    search(key){ //查询操作 如果有就true真没有就返回false
        return this.searchNode(this.root,key)
    }
    searchNode(node,key){
        if(node == null) return false;
        if(this.compareFn(node.key,key)===Compare.LESS_THAN){
            return this.searchNode(node.right,key);
        }else if(this.compareFn(node.key,key)===Compare.BIGGER_THAN){
            return this.searchNode(node.left,key);
        }else{
            return true;
        }
    }
}

以上是简单的插入、遍历和查询的操作
下面给出一些测试数据可以进行测试

var tree = new BinarySearchThree();//创建树
tree.insert(11)//插入树
tree.insert(7)
tree.insert(15)
tree.insert(5)
tree.insert(3)
tree.insert(9)
tree.insert(8)
tree.insert(10)
tree.insert(13)
tree.insert(12)
tree.insert(14)
tree.insert(20)
tree.insert(18)
tree.insert(25)
//进行中序前序和后序遍历
var inStr = ""
tree.inOrderTravers(function(val){
    inStr += " " + val
})
console.log(inStr) // 3 5 7 8 9 10 11 12 13 14 15 18 20 25
var preStr = ""
tree.preOrderTravers(function(val){
    preStr += " " + val
})
console.log(preStr)// 11 7 5 3 9 8 10 15 13 12 14 20 18 25
var postStr = ""
tree.postOrderTravers(function(val){
    postStr += " " + val
})
console.log(postStr) // 3 5 8 10 9 7 12 14 13 18 25 20 15 11
//查找
console.log(tree.search(25))//true