二叉排序树的实现

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
（3）左、右子树也分别为二叉排序树；
（4）没有键值相等的节点。

/**
 * Created by judastree on 15/7/20.
 * 二叉排序树
 */


function Node(value, left, right) {
    this.value = value;
    this.left = left;
    this.right = right;
}
function BST() {
    this.root = null;
}
BST.prototype = {
    add: function (value) {
        var n = new Node(value, null, null);
        if (this.root == null) {
            //根节点为空，直接插入
            this.root = n;
            return true;
        } else {
            //根节点不为空，找到匹配的子节点插
            var current = this.root;
            while (true) {
                if (value < current.value) {
                    //比当前节点小，而且当前节点没有左孩子，直接插入
                    if (current.left == null) {
                        current.left = n;
                        break;
                    } else {
                        //当前节点有左孩子，往下遍历，再和左孩子比较
                        current = current.left;
                    }
                } else if (value > current.value) {
                    //大于当前节点，而且当前节点没有右孩子，直接插入
                    if (current.right == null) {
                        current.right = n;
                        break;
                    } else {
                        //当前节点有右孩子，往下遍历，再和右孩子比较
                        current = current.right;
                    }

                } else {
                    //等于的情况，忽略不进行插入
                    break;
                }
            }
        }

    },
    //中序遍历
    inOrder: function (node, fn) {
        if (node) {
            if (node.left != null) {
                this.inOrder(node.left, fn);
            }
            fn.call(this, node);

            if (node.right != null) {
                this.inOrder(node.right, fn);
            }
        }
    },
    //先序遍历
    preOrder: function (node, fn) {
        if (node) {
            fn.call(this, node);
            if (node.left != null) {
                this.preOrder(node.left, fn);
            }
            if (node.right != null) {
                this.preOrder(node.right, fn);
            }
        }
    },
    //后序遍历
    postOrder: function (node, fn) {
        if (node) {

            if (node.left != null) {
                this.postOrder(node.left, fn);
            }
            if (node.right != null) {
                this.postOrder(node.right, fn);
            }
            fn.call(this, node);
        }
    },
    //默认调用中序遍历
    toArray: function () {
        var result = [];
        this.inOrder(this.root, function (node) {
            result.push(node.value);
        });
        return result;
    },
    toString: function () {
        return this.toArray().toString();
    }
};

var bst = new BST();

bst.add(4);
bst.add(8);
bst.add(3);
bst.add(7);
bst.add(1);
bst.add(2);
console.log("中序遍历：");
console.log(bst.toString());
console.log("先序遍历");
var preResults = [];
bst.preOrder(bst.root, function (node) {
    preResults.push(node.value);
});
console.log(preResults.toString());
console.log("后序遍历");
var postResults = [];
bst.postOrder(bst.root, function (node) {
    postResults.push(node.value);
});
console.log(postResults.toString());

PS: 边参考别人的，写了一个小时。