#include  using namespace std; struct Node {  int key;  struct Node *left, *right; }; // A utility function to create a new BST node Node* newNode(int item) {  Node* temp = new Node;  temp->clave = elemento;  temperatura->izquierda = temperatura->derecha = NULL;  temperatura de retorno; } // Una función de utilidad para realizar un recorrido en orden de BST void inorder(Node* root) { if (root!= NULL) { inorder(root->left);  printf('%d ', raíz->clave);  inorder(raíz->derecha);  } } /* Una función de utilidad para insertar un nuevo nodo con la clave dada en * BST */ Node* insert(Node* node, int key) { /* Si el árbol está vacío, devuelve un nuevo nodo */ if (node ​​= = NULL) devuelve nuevoNodo(clave);  /* De lo contrario, recurra hacia abajo en el árbol */ if (clave< node->clave) nodo->izquierda = insertar(nodo->izquierda, clave);  else nodo->derecha = insertar(nodo->derecha, clave);  /* devuelve el puntero de nodo (sin cambios) */ devuelve nodo; } /* Dado un árbol de búsqueda binario y una clave, esta función elimina la clave y devuelve la nueva raíz */ Node* deleteNode(Node* root, int k) { // Caso base if (root == NULL) return root;  // Si la clave que se va a eliminar es más pequeña que la clave de la raíz, // entonces se encuentra en el subárbol izquierdo si (k< root->clave) { raíz->izquierda = eliminarNodo(raíz->izquierda, k);  devolver raíz;  } // Si la clave que se va a eliminar es mayor que la clave de la raíz, // entonces se encuentra en el subárbol derecho else if (k> raíz->clave) { raíz->derecha = eliminarNodo(raíz->derecha) ,k);  devolver raíz;  } // Si la clave es la misma que la clave de root, entonces este es el nodo que se eliminará // Nodo con solo un hijo o sin hijo if (root->left == NULL) { Node* temp = root-> bien;  eliminar raíz;  temperatura de retorno;  } else if (raíz->derecha == NULL) { Nodo* temp = raíz->izquierda;  eliminar raíz;  temperatura de retorno;  } // Nodo con dos hijos: obtiene el sucesor en orden (el más pequeño // en el subárbol derecho) Nodo* succParent = root;  Nodo* succ = raíz->derecha;  while (succ->left != NULL) { succParent = succ;  succ = succ->izquierda;  } // Copia el contenido del sucesor del orden a este nodo root->key = succ->key;  // Elimina el sucesor en orden if (succParent->left == succ) succParent->left = succ->right;  else succParent->right = succ->right;    eliminar éxito;  devolver raíz; } // Código del controlador int main() { /* Creemos el siguiente BST 50 /  30 70 /  /  20 40 60 80 */ Node* root = NULL;  raíz = insertar(raíz, 50);  raíz = insertar(raíz, 30);  raíz = insertar(raíz, 20);  raíz = insertar(raíz, 40);  raíz = insertar(raíz, 70);  raíz = insertar(raíz, 60);  raíz = insertar(raíz, 80);  printf('BST original: ');  orden(raíz);    printf('

Eliminar un nodo hoja: 20
');  raíz = eliminarNodo(raíz, 20);  printf('Árbol BST modificado después de eliminar el nodo hoja:
');  orden(raíz);  printf('

Eliminar nodo con un solo hijo: 70
');  raíz = eliminarNodo(raíz, 70);  printf('Árbol BST modificado después de eliminar un solo nodo secundario:
');  orden(raíz);  printf('

Eliminar nodo con ambos hijos: 50
');  raíz = eliminarNodo(raíz, 50);  printf('Árbol BST modificado después de eliminar ambos nodos secundarios:
');  orden(raíz);  devolver 0; }>

#include  #include  struct Node {  int key;  struct Node *left, *right; }; // A utility function to create a new BST node struct Node* newNode(int item) {  struct Node* temp = (struct Node*)malloc(sizeof(struct Node));  temp->clave = elemento;  temperatura->izquierda = temperatura->derecha = NULL;  temperatura de retorno; } // Una función de utilidad para realizar un recorrido en orden de BST void inorder(struct Node* root) { if (root!= NULL) { inorder(root->left);  printf('%d ', raíz->clave);  inorder(raíz->derecha);  } } /* Una función de utilidad para insertar un nuevo nodo con la clave dada en BST */ struct Node* insert(struct Node* node, int key) { /* Si el árbol está vacío, devuelve un nuevo nodo */ if (node == NULL) devuelve nuevoNodo(clave);  /* De lo contrario, recurra hacia abajo en el árbol */ if (clave< node->clave) nodo->izquierda = insertar(nodo->izquierda, clave);  else nodo->derecha = insertar(nodo->derecha, clave);  /* devuelve el puntero de nodo (sin cambios) */ devuelve nodo; } /* Dado un árbol de búsqueda binario y una clave, esta función elimina la clave y devuelve la nueva raíz */ struct Node* deleteNode(struct Node* root, int k) { // Caso base if (root == NULL) return raíz;  // Si la clave que se va a eliminar es más pequeña que la clave de la raíz, entonces se encuentra en el subárbol izquierdo si (k< root->clave) { raíz->izquierda = eliminarNodo(raíz->izquierda, k);  devolver raíz;  } // Si la clave que se va a eliminar es mayor que la clave de la raíz, entonces se encuentra en el subárbol derecho else if (k> raíz->clave) { raíz->derecha = eliminarNodo(raíz->derecha, k );  devolver raíz;  } // Si la clave es la misma que la clave de root, entonces este es el nodo que se eliminará // Nodo con solo un hijo o sin hijo if (root->left == NULL) { struct Node* temp = root->derecha;  gratis (raíz);  temperatura de retorno;  } else if (raíz->derecha == NULL) { estructura Nodo* temp = raíz->izquierda;  gratis (raíz);  temperatura de retorno;  } // Nodo con dos hijos: obtiene el sucesor en orden (el más pequeño en el subárbol derecho) struct Node* succParent = root;  estructura Nodo* succ = raíz->derecha;  while (succ->left != NULL) { succParent = succ;  succ = succ->izquierda;  } // Copia el contenido del sucesor del orden a este nodo root->key = succ->key;  // Elimina el sucesor en orden if (succParent->left == succ) succParent->left = succ->right;  else succParent->right = succ->right;  gratis(éxito);  devolver raíz; } // Código del controlador int main() { /* Creemos el siguiente BST 50 /  30 70 /  /  20 40 60 80 */ struct Node* root = NULL;  raíz = insertar(raíz, 50);  insertar(raíz, 30);  insertar(raíz, 20);  insertar(raíz, 40);  insertar(raíz, 70);  insertar(raíz, 60);  insertar(raíz, 80);  printf('BST original: ');  orden(raíz);    printf('

Eliminar un nodo hoja: 20
');  raíz = eliminarNodo(raíz, 20);  printf('Árbol BST modificado después de eliminar el nodo hoja:
');  orden(raíz);  printf('

Eliminar nodo con un solo hijo: 70
');  raíz = eliminarNodo(raíz, 70);  printf('Árbol BST modificado después de eliminar un solo nodo secundario:
');  orden(raíz);  printf('

Eliminar nodo con ambos hijos: 50
');  raíz = eliminarNodo(raíz, 50);  printf('Árbol BST modificado después de eliminar ambos nodos secundarios:
');  orden(raíz);  devolver 0; }>

class Node {  int key;  Node left, right;  Node(int item) {  key = item;  left = right = null;  } } class BinaryTree {  Node root;  BinaryTree() {  root = null;  }  // A utility function to insert a new node with the given key  Node insert(Node node, int key) {  // If the tree is empty, return a new node  if (node == null) {  return new Node(key);  }  // Otherwise, recur down the tree  if (key < node.key) {  node.left = insert(node.left, key);  } else if (key>nodo.clave) { nodo.derecha = insertar(nodo.derecha, clave);  } // devuelve el puntero del nodo (sin cambios) return node;  } // Una función de utilidad para realizar un recorrido en orden de BST void inorder(Node root) { if (root!= null) { inorder(root.left);  System.out.print(root.key + ' ');  orden(raíz.derecha);  } } // Dado un árbol de búsqueda binario y una clave, esta función elimina la clave y devuelve el nuevo Nodo raíz eliminarNodo(Nodo raíz, int clave) { // Caso base if (root == null) { return root;  } // Si la clave que se va a eliminar es más pequeña que la clave de la raíz, entonces se encuentra en el subárbol izquierdo if (key< root.key) {  root.left = deleteNode(root.left, key);  }  // If the key to be deleted is greater than the root's key, then it lies in the right subtree  else if (key>raíz.clave) { raíz.derecha = eliminarNodo(raíz.derecha, clave);  } // Si la clave es la misma que la clave de root, entonces este es el nodo que se eliminará else { // Nodo con un solo hijo o sin hijo if (root.left == null) { return root.right;  } else if (root.right == null) { return root.left;  } // Nodo con dos hijos: obtiene el sucesor en orden (el más pequeño en el subárbol derecho) root.key = minValue(root.right);  // Eliminar el sucesor del orden root.right = deleteNode(root.right, root.key);  } devolver raíz;  } int minValue (raíz del nodo) { int minv = root.key;  mientras (root.left! = nulo) { minv = root.left.key;  raíz = raíz.izquierda;  } devolver minv;  } // Código del controlador public static void main(String[] args) { árbol BinaryTree = new BinaryTree();  /* Creemos el siguiente BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50);  árbol.insertar(árbol.raíz, 30);  árbol.insertar(árbol.raíz, 20);  árbol.insertar(árbol.raíz, 40);  árbol.insertar(árbol.raíz, 70);  árbol.insertar(árbol.raíz, 60);  árbol.insertar(árbol.raíz, 80);  System.out.print('BST original: ');  árbol.inorder(árbol.raíz);  Sistema.out.println();  System.out.println('
Eliminar un nodo hoja: 20');  árbol.raíz = árbol.deleteNode(árbol.raíz, 20);  System.out.print('Árbol BST modificado después de eliminar el nodo hoja:
');  árbol.inorder(árbol.raíz);  Sistema.out.println();  System.out.println('
Eliminar nodo con un solo hijo: 70');  árbol.raíz = árbol.deleteNode(árbol.raíz, 70);  System.out.print('Árbol BST modificado después de eliminar un solo nodo secundario:
');  árbol.inorder(árbol.raíz);  Sistema.out.println();  System.out.println('
Eliminar nodo con ambos hijos: 50');  árbol.raíz = árbol.deleteNode(árbol.raíz, 50);  System.out.print('Árbol BST modificado después de eliminar ambos nodos secundarios:
');  árbol.inorder(árbol.raíz);  } }>

class Node: def __init__(self, key): self.key = key self.left = None self.right = None class BinaryTree: def __init__(self): self.root = None # A utility function to insert a new node with the given key def insert(self, node, key): # If the tree is empty, return a new node if node is None: return Node(key) # Otherwise, recur down the tree if key < node.key: node.left = self.insert(node.left, key) elif key>node.key: node.right = self.insert(node.right, key) # devolver el puntero de nodo (sin cambios) return node # Una función de utilidad para realizar un recorrido en orden de BST def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # Dado un árbol de búsqueda binario y una clave, esta función elimina la clave y devuelve la nueva raíz def deleteNode (self, root, key): # Caso base si la raíz es Ninguna: devuelve raíz # Si la clave que se va a eliminar es más pequeña que la clave de la raíz, entonces se encuentra en el subárbol izquierdo si es clave< root.key: root.left = self.deleteNode(root.left, key) # If the key to be deleted is greater than the root's key, then it lies in the right subtree elif key>root.key: root.right = self.deleteNode(root.right, key) # Si la clave es la misma que la clave de root, entonces este es el nodo que se eliminará. De lo contrario: # Nodo con solo un hijo o sin hijo si root.left es Ninguno: devuelve root.right elif root.right es Ninguno: devuelve root.left # Nodo con dos hijos: obtiene el sucesor en orden (el más pequeño en el subárbol derecho) root.key = self.minValue(root.right) # Eliminar el sucesor del orden root.right = self.deleteNode(root.right, root.key) return root def minValue(self, root): minv = root.key while root.left: minv = root.left.key root = root.left return minv # Código de controlador if __name__ == '__main__': tree = BinaryTree() # Creemos el siguiente BST # 50 # /  # 30 70 # /  /  # 20 40 60 80 tree.root = árbol.insertar(árbol.raíz, 50) árbol.insertar(árbol.raíz, 30) árbol.insertar(árbol.raíz, 20) árbol.insertar(árbol.raíz, 40) árbol.insertar(árbol.raíz, 70 ) tree.insert(tree.root, 60) tree.insert(tree.root, 80) print('BST original:', end=' ') tree.inorder(tree.root) print() imprimir ('
Eliminar un nodo hoja: 20') tree.root = tree.deleteNode(tree.root, 20) print('Árbol BST modificado después de eliminar el nodo hoja:') tree.inorder(tree.root) print() print('
Eliminar nodo con un solo hijo: 70') tree.root = tree.deleteNode(tree.root, 70) print('Árbol BST modificado después de eliminar un solo nodo hijo:') árbol. inorder(tree.root) print() print('
Eliminar nodo con ambos hijos: 50') tree.root = tree.deleteNode(tree.root, 50) print('Árbol BST modificado después de eliminar ambos nodos secundarios :') árbol.inorder(árbol.raíz)>

using System; public class Node {  public int key;  public Node left, right;  public Node(int item) {  key = item;  left = right = null;  } } public class BinaryTree {  public Node root;  // A utility function to insert a new node with the given key  public Node Insert(Node node, int key) {  // If the tree is empty, return a new node  if (node == null)  return new Node(key);  // Otherwise, recur down the tree  if (key < node.key)  node.left = Insert(node.left, key);  else if (key>nodo.clave) nodo.derecha = Insertar(nodo.derecha, clave);  // devuelve el puntero del nodo (sin cambios) return node;  } // Una función de utilidad para realizar un recorrido en orden de BST public void Inorder(Node root) { if (root!= null) { Inorder(root.left);  Console.Write(root.key + ' ');  En orden (raíz.derecha);  } } // Dado un árbol de búsqueda binario y una clave, esta función elimina la clave y devuelve la nueva raíz public Node DeleteNode(Node root, int key) { // Caso base if (root == null) return root;  // Si la clave que se va a eliminar es más pequeña que la clave de la raíz, entonces se encuentra en el subárbol izquierdo if (key< root.key)  root.left = DeleteNode(root.left, key);  // If the key to be deleted is greater than the root's key, then it lies in the right subtree  else if (key>raíz.clave) raíz.derecha = EliminarNodo(raíz.derecha, clave);  // Si la clave es la misma que la clave de root, entonces este es el nodo que se eliminará else { // Nodo con solo un hijo o sin hijo if (root.left == null) return root.right;  de lo contrario, si (root.right == null) devuelve root.left;  // Nodo con dos hijos: obtiene el sucesor en orden (el más pequeño en el subárbol derecho) root.key = MinValue(root.right);  // Eliminar el sucesor del orden root.right = DeleteNode(root.right, root.key);  } devolver raíz;  } public int MinValue (raíz del nodo) { int minv = root.key;  mientras (root.left! = nulo) { minv = root.left.key;  raíz = raíz.izquierda;  } devolver minv;  } // Código del controlador public static void Main(string[] args) { árbol BinaryTree = new BinaryTree();  /* Creemos el siguiente BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.Insert(tree.root, 50);  árbol.Insertar(árbol.raíz, 30);  árbol.Insertar(árbol.raíz, 20);  árbol.Insertar(árbol.raíz, 40);  árbol.Insertar(árbol.raíz, 70);  árbol.Insertar(árbol.raíz, 60);  árbol.Insertar(árbol.raíz, 80);  Console.Write('BST original: ');  árbol.Inorder(árbol.raíz);  Consola.WriteLine();  Console.WriteLine('
Eliminar un nodo hoja: 20');  árbol.raíz = árbol.DeleteNode(árbol.raíz, 20);  Console.Write('Árbol BST modificado después de eliminar el nodo hoja:
');  árbol.Inorder(árbol.raíz);  Consola.WriteLine();  Console.WriteLine('
Eliminar nodo con un solo hijo: 70');  árbol.raíz = árbol.DeleteNode(árbol.raíz, 70);  Console.Write('Árbol BST modificado después de eliminar el nodo secundario único:
');  árbol.Inorder(árbol.raíz);  Consola.WriteLine();  Console.WriteLine('
Eliminar nodo con ambos hijos: 50');  árbol.raíz = árbol.DeleteNode(árbol.raíz, 50);  Console.Write('Árbol BST modificado después de eliminar ambos nodos secundarios:
');  árbol.Inorder(árbol.raíz);  }>

class Node {  constructor(key) {  this.key = key;  this.left = null;  this.right = null;  } } class BinaryTree {  constructor() {  this.root = null;  }  // A utility function to insert a new node with the given key  insert(node, key) {  // If the tree is empty, return a new node  if (node === null)  return new Node(key);  // Otherwise, recur down the tree  if (key < node.key)  node.left = this.insert(node.left, key);  else if (key>nodo.clave) nodo.derecho = this.insert(nodo.derecho, clave);  // devuelve el puntero del nodo (sin cambios) return node;  } // Una función de utilidad para realizar un recorrido en orden de BST inorder(node) { if (node!== null) { this.inorder(node.left);  console.log(nodo.key + ' ');  this.inorder(nodo.derecha);  } } // Dado un árbol de búsqueda binario y una clave, esta función elimina la clave y devuelve la nueva raíz eliminarNodo(raíz, clave) { // Caso base if (root === null) return root;  // Si la clave que se va a eliminar es más pequeña que la clave de la raíz, entonces se encuentra en el subárbol izquierdo if (key< root.key)  root.left = this.deleteNode(root.left, key);  // If the key to be deleted is greater than the root's key, then it lies in the right subtree  else if (key>raíz.clave) raíz.derecha = this.deleteNode(raíz.derecha, clave);  // Si la clave es la misma que la clave de root, entonces este es el nodo que se eliminará else { // Nodo con solo un hijo o sin hijo if (root.left === null) return root.right;  de lo contrario, si (root.right === null) devuelve root.left;  // Nodo con dos hijos: obtiene el sucesor en orden (el más pequeño en el subárbol derecho) root.key = this.minValue(root.right);  // Eliminar el sucesor del orden root.right = this.deleteNode(root.right, root.key);  } devolver raíz;  } minValue(nodo) { let minv = nodo.clave;  while (nodo.izquierda! == nulo) { minv = nodo.izquierda.clave;  nodo = nodo.izquierda;  } devolver minv;  } } // Código del controlador let tree = new BinaryTree(); /* Creemos el siguiente BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50); árbol.insertar(árbol.raíz, 30); árbol.insertar(árbol.raíz, 20); árbol.insertar(árbol.raíz, 40); árbol.insertar(árbol.raíz, 70); árbol.insertar(árbol.raíz, 60); árbol.insertar(árbol.raíz, 80); console.log('BST original:'); árbol.inorder(árbol.raíz); console.log('

Eliminar un nodo hoja: 20'); árbol.raíz = árbol.deleteNode(árbol.raíz, 20); console.log('Árbol BST modificado después de eliminar el nodo hoja:'); árbol.inorder(árbol.raíz); console.log('

Eliminar nodo con un solo hijo: 70'); árbol.raíz = árbol.deleteNode(árbol.raíz, 70); console.log('Árbol BST modificado después de eliminar el nodo secundario único:'); árbol.inorder(árbol.raíz); console.log('

Eliminar nodo con ambos hijos: 50'); árbol.raíz = árbol.deleteNode(árbol.raíz, 50); console.log('Árbol BST modificado después de eliminar ambos nodos secundarios:'); árbol.inorder(árbol.raíz);>