Estoy tratando de implementar un árbol de búsqueda binaria (BST) con javascript. Se me ocurrieron 2 versiones.

Aquí está la primera versión

 class Node { constructor(value) { this.value = value this.left = null this.right = null } } class Tree { constructor(value) { if (value != null) { this.root = new Node(value) } else { return null; } } addNode(parent, n) { if (n.value === parent.value) { return; } else if (n.value < parent.value) { if (parent.left == null) { parent.left = n; } else { this.addNode(parent.left, n) } } else { // n.value > parent.value if (parent.right == null) { parent.right = n; } else { this.addNode(parent.right, n) } } } addValue(val) { let n = new Node(val); if (this.root == null) { this.root = n; } else { this.addNode(this.root, n); } } }

Definí un Node de clase simple y la clase Tree .

La clase Node abstrae cualquier nodo que va desde la raíz hasta una hoja.

La clase Tree maneja todo el negocio, especialmente el método addNode . Por el contrario, mi segunda versión puso el método addNode en la clase Node . Aquí está el código

 class Node { constructor(value) { this.value = value this.left = null this.right = null } addNode(n) { if (n.value == this.value) { return; } else if (n.value < this.value) { if (this.left == null) { this.left = n; } else { this.left.addNode(n) } } else { if (this.right == null) { this.right = n; } else { this.right.addNode(n) } } } } class Tree { constructor(value) { if (value != null) { this.root = new Node(value) } else { return null; } } addValue(val) { let n = new Node(val); if (this.root == null) { this.root = n; } else { this.root.addNode(n); } } }

Ambas versiones funcionan como se esperaba. Sé que debería agregar más verificación, en caso de que algo como tree.addValue(); sucede

Me gustaría saber con qué versión debo ir, y por qué. ¿Existe algún tipo de principio o consideración para tomar tal decisión?