Merge branch 'js' into main with OOP refactor for normal challenges

Author: IbatoLionDev

2-NORMAL/JavaScript/1-binary-search-tree-operations/article.md

@@ -0,0 +1,116 @@
+# Challenge Description and Solution
+
+## English Version
+
+### Challenge Description
+Implement a binary search tree (BST) that supports insertions, searches, and deletions. Test different traversals (in-order, pre-order, and post-order) to ensure the tree updates correctly.
+
+### Code Explanation
+The BST is implemented with a `Node` class representing each node and a `BinarySearchTree` class managing the tree. The tree supports:
+- `insert(key)`: Inserts a key into the BST.
+- `search(key)`: Searches for a key in the BST.
+- `delete(key)`: Deletes a key from the BST.
+- Traversal methods: `inorder()`, `preorder()`, and `postorder()` return arrays of keys in respective traversal orders.
+
+The deletion handles three cases:
+- Node with no children.
+- Node with one child.
+- Node with two children (replaces with inorder successor).
+
+### Relevant Code Snippet
+
+```javascript
+class BinarySearchTree {
+    // ... class implementation as in bst.js ...
+}
+```
+
+### Example Usage
+
+```javascript
+const bst = new BinarySearchTree();
+[50, 30, 20, 40, 70, 60, 80].forEach(key => bst.insert(key));
+
+console.log("Inorder traversal:");
+console.log(bst.inorder());
+
+console.log("Preorder traversal:");
+console.log(bst.preorder());
+
+console.log("Postorder traversal:");
+console.log(bst.postorder());
+
+const key = 40;
+const found = bst.search(key);
+console.log(`Search for ${key}: ${found ? "Found" : "Not found"}`);
+
+bst.delete(20);
+console.log("Inorder traversal after deleting 20:");
+console.log(bst.inorder());
+
+bst.delete(30);
+console.log("Inorder traversal after deleting 30:");
+console.log(bst.inorder());
+
+bst.delete(50);
+console.log("Inorder traversal after deleting 50:");
+console.log(bst.inorder());
+```
+
+---
+
+## Versión en Español
+
+### Descripción del Reto
+Implementa un árbol binario de búsqueda (BST) que soporte inserciones, búsquedas y eliminaciones. Prueba diferentes recorridos (inorden, preorden y postorden) para asegurar que el árbol se actualice correctamente.
+
+### Explicación del Código
+El BST se implementa con una clase `Node` que representa cada nodo y una clase `BinarySearchTree` que maneja el árbol. El árbol soporta:
+- `insert(key)`: Inserta una clave en el BST.
+- `search(key)`: Busca una clave en el BST.
+- `delete(key)`: Elimina una clave del BST.
+- Métodos de recorrido: `inorder()`, `preorder()` y `postorder()` que retornan arreglos de claves en los respectivos órdenes de recorrido.
+
+La eliminación maneja tres casos:
+- Nodo sin hijos.
+- Nodo con un hijo.
+- Nodo con dos hijos (se reemplaza con el sucesor en inorden).
+
+### Fragmento de Código Relevante
+
+```javascript
+class BinarySearchTree {
+    // ... implementación de la clase como en bst.js ...
+}
+```
+
+### Ejemplo de Uso
+
+```javascript
+const bst = new BinarySearchTree();
+[50, 30, 20, 40, 70, 60, 80].forEach(key => bst.insert(key));
+
+console.log("Recorrido inorden:");
+console.log(bst.inorder());
+
+console.log("Recorrido preorden:");
+console.log(bst.preorder());
+
+console.log("Recorrido postorden:");
+console.log(bst.postorder());
+
+const key = 40;
+const found = bst.search(key);
+console.log(`Búsqueda de ${key}: ${found ? "Encontrado" : "No encontrado"}`);
+
+bst.delete(20);
+console.log("Recorrido inorden después de eliminar 20:");
+console.log(bst.inorder());
+
+bst.delete(30);
+console.log("Recorrido inorden después de eliminar 30:");
+console.log(bst.inorder());
+
+bst.delete(50);
+console.log("Recorrido inorden después de eliminar 50:");
+console.log(bst.inorder());

2-NORMAL/JavaScript/1-binary-search-tree-operations/proposed-solution/bst.js

@@ -0,0 +1,95 @@
+// bst.js - Binary Search Tree implementation
+
+function Node(key) {
+  this.key = key;
+  this.left = null;
+  this.right = null;
+}
+
+class BinarySearchTree {
+  constructor() {
+    this.root = null;
+  }
+
+  insert(key) {
+    this.root = this._insertRec(this.root, key);
+  }
+
+  _insertRec(node, key) {
+    if (node === null) {
+      return new Node(key);
+    }
+    if (key < node.key) {
+      node.left = this._insertRec(node.left, key);
+    } else {
+      node.right = this._insertRec(node.right, key);
+    }
+    return node;
+  }
+
+  search(key) {
+    return this._searchRec(this.root, key);
+  }
+
+  _searchRec(node, key) {
+    if (node === null) return false;
+    if (key === node.key) return true;
+    if (key < node.key) return this._searchRec(node.left, key);
+    else return this._searchRec(node.right, key);
+  }
+
+  delete(key) {
+    this.root = this._deleteRec(this.root, key);
+  }
+
+  _deleteRec(node, key) {
+    if (node === null) return null;
+
+    if (key < node.key) {
+      node.left = this._deleteRec(node.left, key);
+    } else if (key > node.key) {
+      node.right = this._deleteRec(node.right, key);
+    } else {
+      if (node.left === null) return node.right;
+      if (node.right === null) return node.left;
+
+      node.key = this._minValue(node.right);
+      node.right = this._deleteRec(node.right, node.key);
+    }
+    return node;
+  }
+
+  _minValue(node) {
+    let current = node;
+    while (current.left !== null) {
+      current = current.left;
+    }
+    return current.key;
+  }
+
+  inorder() {
+    return this._traverse(this.root, []);
+  }
+
+  preorder() {
+    return this._traverse(this.root, [], "preorder");
+  }
+
+  postorder() {
+    return this._traverse(this.root, [], "postorder");
+  }
+
+  _traverse(node, result, order = "inorder") {
+    if (node === null) return result;
+
+    if (order === "preorder") result.push(node.key);
+    this._traverse(node.left, result, order);
+    if (order === "inorder") result.push(node.key);
+    this._traverse(node.right, result, order);
+    if (order === "postorder") result.push(node.key);
+
+    return result;
+  }
+}
+
+module.exports = { BinarySearchTree };

2-NORMAL/JavaScript/1-binary-search-tree-operations/proposed-solution/main.js

@@ -0,0 +1,40 @@
+/*
+Challenge: Implement a binary search tree (BST) that supports insertions, searches, and deletions.
+Test different traversals (in-order, pre-order, and post-order) to ensure the tree updates correctly.
+*/
+
+// main.js - Example usage of BinarySearchTree
+
+import { BinarySearchTree } from './bst.js';
+
+function main() {
+  const bst = new BinarySearchTree();
+  [50, 30, 20, 40, 70, 60, 80].forEach((key) => bst.insert(key));
+
+  console.log("Inorder traversal:");
+  console.log(bst.inorder());
+
+  console.log("Preorder traversal:");
+  console.log(bst.preorder());
+
+  console.log("Postorder traversal:");
+  console.log(bst.postorder());
+
+  const key = 40;
+  const found = bst.search(key);
+  console.log(`Search for ${key}: ${found ? "Found" : "Not found"}`);
+
+  bst.delete(20);
+  console.log("Inorder traversal after deleting 20:");
+  console.log(bst.inorder());
+
+  bst.delete(30);
+  console.log("Inorder traversal after deleting 30:");
+  console.log(bst.inorder());
+
+  bst.delete(50);
+  console.log("Inorder traversal after deleting 50:");
+  console.log(bst.inorder());
+}
+
+main();