Javascript 如何在非有序二叉树中搜索节点？

我正在构建一个非有序二叉树，看起来像这样

                                  1 
                                /   \ 
                              30     2 
                                \   / \ 
                                31 4   3
                                / \ 
                              34   32
                              .... and so on

我的实现创建如下

function BinarySearchTree() {
    this._root = null;
}

BinarySearchTree.prototype = {

    //restore constructor
    constructor: BinarySearchTree,

    add: function(value,whereToAdd,nodeToAdd){
        //create a new item object, place data in
        var node = {
                value: value,
                left: null,
                right: null
            },

        //used to traverse the structure
            current;

        //special case: no items in the tree yet
        if (this._root === null || whereToAdd === null || whereToAdd === undefined){
            this._root = node;
        } else {
            current = nodeToAdd;

            while(true){

                //if the new value is less than this node's value, go left
                if (whereToAdd === "no"){

                    //if there's no left, then the new node belongs there
                    if (current.left === null){
                        current.left = node;
                        break;
                    } else {
                        current = current.left;
                    }

                    //if the new value is greater than this node's value, go right
                } else if (whereToAdd === "yes"){

                    //if there's no right, then the new node belongs there
                    if (current.right === null){
                        current.right = node;
                        break;
                    } else {
                        current = current.right;
                    }

                    //if the new value is equal to the current one, just ignore
                } else {
                    break;
                }
            }
        }
    },

         traverse: function(process){

        //helper function
        function inOrder(node){
            if (node){

                //traverse the left subtree
                if (node.left !== null){
                    inOrder(node.left);
                }

                //call the process method on this node
                process.call(this, node);

                //traverse the right subtree
                if (node.right !== null){
                    inOrder(node.right);
                }
            }
        }

        //start with the root
        inOrder(this._root);
    },


    contains: function(value){
        var found       = false,
            current     = this._root;

        //make sure there's a node to search
        while(!found && current){

            //if the value is less than the current node's, go left
            if (value < current.value){
                current = current.left;

                //if the value is greater than the current node's, go right
            } else if (value > current.value){
                current = current.right;

                //values are equal, found it!
            } else {
                found = true;
            }
        }

        //only proceed if the node was found
        return current;
    },

    size: function(){
        var length = 0;

        this.traverse(function(node){
            length++;
        });

        return length;
    },

    toArray: function(){
        var result = [];

        this.traverse(function(node){
            result.push(node.value);
        });

        return result;
    },

    toString: function(){
        return this.toArray().toString();
    },

};

function ArmTheTree(Tree){
    Tree.add(1,null,null);
    Tree.add(30,"no",Tree.contains(1));
    Tree.add(31,"yes",Tree.contains(30));
    Tree.add(32,"yes",Tree.contains(31));
    Tree.add(33,"no",Tree.contains(32));
    Tree.add(34,"no",Tree.contains(31));
    Tree.add(35,"yes",Tree.contains(34));
    Tree.add(36,"yes",Tree.contains(35));

    Tree.add(2,"yes",Tree.contains(1));
    Tree.add(4,"no",Tree.contains(2));
    Tree.add(23,"no",Tree.contains(4));
    Tree.add(24,"yes",Tree.contains(23));
    Tree.add(25,"no",Tree.contains(23));
    Tree.add(26,"yes",Tree.contains(25));
    Tree.add(27,"no",Tree.contains(25));
    Tree.add(28,"no",Tree.contains(27));
    Tree.add(29,"yes",Tree.contains(27));

    Tree.add(3,"yes",Tree.contains(2));
    Tree.add(5,"yes",Tree.contains(3));

    Tree.add(6,"no",Tree.contains(3));
    Tree.add(7,"yes",Tree.contains(6));
    Tree.add(8,"no",Tree.contains(6));
    Tree.add(9,"yes",Tree.contains(8));

    Tree.add(17,"no",Tree.contains(9));
    Tree.add(19,"yes",Tree.contains(17));
    Tree.add(20,"no",Tree.contains(17));
    Tree.add(21,"yes",Tree.contains(20));


    Tree.add(10,"yes",Tree.contains(9));
    Tree.add(11,"yes",Tree.contains(10));

    Tree.add(12,"no",Tree.contains(10));
    Tree.add(15,"yes",Tree.contains(12));
    Tree.add(13,"no",Tree.contains(12));
    Tree.add(14,"yes",Tree.contains(13));
    Tree.add(16,"no",Tree.contains(13));

};
Tree = new BinarySearchTree();
ArmTheTree(Tree);



});

函数BinarySearchTree（）{
这是.\u root=null；
}
BinarySearchTree.prototype={
//还原构造函数
构造函数：BinarySearchTree，
添加：函数（值、添加位置、添加节点）{
//创建新项目对象，将数据放入
变量节点={
价值：价值，
左：空，
右：空
},
//用于遍历结构
现在的
//特殊情况：树中还没有项目
if（this._root==null | | whereToAdd==null | | whereToAdd==undefined）{
这个。_根=节点；
}否则{
当前=节点添加；
while（true）{
//如果新值小于此节点的值，请向左移动
如果（此处添加==“否”）{
//如果没有剩余节点，则新节点属于该节点
if（current.left==null）{
current.left=节点；
打破
}否则{
current=current.left；
}
//如果新值大于此节点的值，请向右移动
}else if（whereToAdd==“是”）{
//如果没有权限，那么新节点就属于那里
if（current.right==null）{
current.right=节点；
打破
}否则{
current=current.right；
}
//如果新值等于当前值，只需忽略即可
}否则{
打破
}
}
}
},
遍历：函数（进程）{
//辅助函数
函数顺序（节点）{
如果（节点）{
//遍历左子树
if（node.left！==null）{
顺序（node.left）；
}
//在此节点上调用process方法
process.call（本节点）；
//遍历右子树
if（node.right！==null）{
顺序（node.right）；
}
}
}
//从根开始
顺序（此._根）；
},
包含：函数（值）{
var found=false，
电流=此根；
//确保有要搜索的节点
while（！found&¤t）{
//如果该值小于当前节点的值，则向左移动
如果（值<当前值）{
current=current.left；
//如果该值大于当前节点的值，请向右移动
}else if（值>当前值）{
current=current.right；
//值相等，找到了！
}否则{
发现=真；
}
}
//仅当找到节点时才继续
回流；
},
大小：函数（）{
变量长度=0；
此.遍历（函数（节点）{
长度++；
});
返回长度；
},
toArray:函数（）{
var结果=[]；
此.遍历（函数（节点）{
结果推送（节点值）；
});
返回结果；
},
toString:function（）{
返回此.toArray（）.toString（）；
},
};
功能臂树（树）{
add（1，null，null）；
Tree.add（30，“no”，Tree.contains（1））；
Tree.add（31，“yes”，Tree.contains（30））；
Tree.add（32，“yes”，Tree.contains（31））；
Tree.add（33，“no”，Tree.contains（32））；
Tree.add（34，“no”，Tree.contains（31））；
Tree.add（35，“yes”，Tree.contains（34））；
Tree.add（36，“yes”，Tree.contains（35））；
添加（2，“是”，Tree.contains（1））；
Tree.add（4，“no”，Tree.contains（2））；
Tree.add（23，“no”，Tree.contains（4））；
添加（24，“是”，Tree.contains（23））；
Tree.add（25，“no”，Tree.contains（23））；
添加（26，“是”，Tree.contains（25））；
Tree.add（27，“no”，Tree.contains（25））；
Tree.add（28，“no”，Tree.contains（27））；
Tree.add（29，“yes”，Tree.contains（27））；
添加（3，“是”，Tree.contains（2））；
添加（5，“是”，Tree.contains（3））；
Tree.add（6，“no”，Tree.contains（3））；
添加（7，“是”，Tree.contains（6））；
Tree.add（8，“no”，Tree.contains（6））；
添加（9，“是”，Tree.contains（8））；
Tree.add（17，“no”，Tree.contains（9））；
Tree.add（19，“yes”，Tree.contains（17））；
Tree.add（20，“no”，Tree.contains（17））；
添加（21，“是”，Tree.contains（20））；
添加（10，“是”，Tree.contains（9））；
Tree.add（11，“yes”，Tree.contains（10））；
Tree.add（12，“no”，Tree.contains（10））；
添加（15，“是”，Tree.contains（12））；
Tree.add（13，“no”，Tree.contains（12））；
Tree.add（14，“yes”，Tree.contains（13））；
Tree.add（16，“no”，Tree.contains（13））；
};
Tree=新的二进制搜索树（）；
扶手树；
});

---

如何使用横向函数的实现在二叉树中搜索节点？我的意图是使用这棵树进行一场真实或错误的游戏

您可以使用递归方法和辅助函数

\u contains

，该函数在树及其子树中的节点中查找值：

...,

_contains: function(node, value) {
    if (node === null) return null;
    if (node.value == value) return node;

    // search in left subtree
    var n = this._contains(node.left, value);
    if (n) return n;

    // search in right subtree
    return this._contains(node.right, value);
},

contains: function(value) {
    return this._contains(this._root, value);
},

...

如果未找到节点，函数将返回

null

如果让函数

add

返回新添加的节点，则在构建树时可以节省大量的树漫游，并且可能不需要

contains

函数。而不是：

Tree.add(1, null, null);
Tree.add(30, "no", Tree.contains(1));
Tree.add(31, "yes", Tree.contains(30));

你会得到：

var n = {};

n[1] = Tree.add(1, null, null);
n[30] = Tree.add(30, "no", n[1]);
n[31] = Tree.add(31, "yes", n[30]);

---

您可以使用递归方法和辅助函数

\u contains

，该函数在树及其子树中的节点中查找值：

...,

_contains: function(node, value) {
    if (node === null) return null;
    if (node.value == value) return node;

    // search in left subtree
    var n = this._contains(node.left, value);
    if (n) return n;

    // search in right subtree
    return this._contains(node.right, value);
},

contains: function(value) {
    return this._contains(this._root, value);
},

...

如果未找到节点，函数将返回

null

如果让函数

add

返回新添加的节点，则可以为自己节省很多时间