#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->clé = élément ;  temp->gauche = temp->droite = NULL ;  température de retour ; } // Une fonction utilitaire pour effectuer un parcours dans l'ordre de BST void inorder(Node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', racine->clé);  dans l'ordre (racine-> droite);  } } /* Une fonction utilitaire pour insérer un nouveau nœud avec une clé donnée dans * BST */ Node* insert(Node* node, int key) { /* Si l'arborescence est vide, renvoie un nouveau nœud */ if (node ​​= = NULL) return newNode(clé);  /* Sinon, récurrence dans l'arborescence */ if (clé< node->clé) nœud->gauche = insert(nœud->gauche, clé);  else node->right = insert(node->right, key);  /* renvoie le pointeur de nœud (inchangé) */ return node; } /* Étant donné un arbre de recherche binaire et une clé, cette fonction supprime la clé et renvoie la nouvelle racine */ Node* deleteNode(Node* root, int k) { // Cas de base if (root == NULL) return root;  // Si la clé à supprimer est plus petite que la clé de la racine, // alors elle se trouve dans le sous-arbre de gauche if (k< root->clé) { racine->gauche = deleteNode(racine->gauche, k);  retourner la racine ;  } // Si la clé à supprimer est supérieure à la clé de la racine, // alors elle se trouve dans le sous-arbre de droite sinon if (k> root->key) { root->right = deleteNode(root->right ,k);  retourner la racine ;  } // Si la clé est la même que celle de root, alors c'est le nœud à supprimer // Nœud avec un seul enfant ou aucun enfant if (root->left == NULL) { Node* temp = root-> droite;  supprimer la racine ;  température de retour ;  } else if (root->right == NULL) { Node* temp = root->left;  supprimer la racine ;  température de retour ;  } // Nœud avec deux enfants : Récupère le successeur dans l'ordre (le plus petit // dans le sous-arbre de droite) Node* succParent = root;  Noeud* succ = racine->droite ;  while (succ->left != NULL) { succParent = succ;  succ = succ->gauche;  } // Copiez le contenu du successeur de l'ordre dans ce nœud root->key = succ->key;  // Supprime le successeur dans l'ordre if (succParent->left == succ) succParent->left = succ->right;  sinon succParent->right = succ->right;    supprimer succ;  retourner la racine ; } // Driver Code int main() { /* Créons les BST suivants 50 /  30 70 /  /  20 40 60 80 */ Node* root = NULL;  racine = insert(racine, 50);  racine = insert(racine, 30);  racine = insert(racine, 20);  racine = insert(racine, 40);  racine = insert(racine, 70);  racine = insert(racine, 60);  racine = insert(racine, 80);  printf('BST d'origine : ');  dans l'ordre (racine);    printf('

Supprimer un nœud feuille : 20
');  racine = deleteNode (racine, 20);  printf('Arborescence BST modifiée après la suppression du nœud feuille :
');  dans l'ordre (racine);  printf('

Supprimer le nœud avec un seul enfant : 70
');  racine = deleteNode (racine, 70);  printf('Arborescence BST modifiée après la suppression d'un seul nœud enfant :
');  dans l'ordre (racine);  printf('

Supprimer le nœud avec les deux enfants : 50
');  racine = deleteNode (racine, 50);  printf('Arborescence BST modifiée après la suppression des deux nœuds enfants :
');  dans l'ordre (racine);  renvoie 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->clé = élément ;  temp->gauche = temp->droite = NULL ;  température de retour ; } // Une fonction utilitaire pour effectuer un parcours dans l'ordre de BST void inorder(struct Node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', racine->clé);  dans l'ordre (racine-> droite);  } } /* Une fonction utilitaire pour insérer un nouveau nœud avec une clé donnée dans BST */ struct Node* insert(struct Node* node, int key) { /* Si l'arborescence est vide, renvoie un nouveau nœud */ if (node == NULL) return newNode(clé);  /* Sinon, récurrence dans l'arborescence */ if (clé< node->clé) nœud->gauche = insert(nœud->gauche, clé);  else node->right = insert(node->right, key);  /* renvoie le pointeur de nœud (inchangé) */ return node; } /* Étant donné un arbre de recherche binaire et une clé, cette fonction supprime la clé et renvoie la nouvelle racine */ struct Node* deleteNode(struct Node* root, int k) { // Cas de base if (root == NULL) return racine;  // Si la clé à supprimer est plus petite que la clé de la racine, alors elle se trouve dans le sous-arbre de gauche if (k< root->clé) { racine->gauche = deleteNode(racine->gauche, k);  retourner la racine ;  } // Si la clé à supprimer est supérieure à la clé de la racine, alors elle se trouve dans le sous-arbre de droite sinon if (k> root->key) { root->right = deleteNode(root->right, k );  retourner la racine ;  } // Si la clé est la même que celle de root, alors c'est le nœud à supprimer // Nœud avec un seul enfant ou aucun enfant if (root->left == NULL) { struct Node* temp = root-> c'est vrai ;  gratuit(racine);  température de retour ;  } else if (root->right == NULL) { struct Node* temp = root->left;  gratuit(racine);  température de retour ;  } // Nœud avec deux enfants : Récupère le successeur dans l'ordre (le plus petit dans le sous-arbre de droite) struct Node* succParent = root;  struct Node* succ = racine->droite ;  while (succ->left != NULL) { succParent = succ;  succ = succ->gauche;  } // Copiez le contenu du successeur de l'ordre dans ce nœud root->key = succ->key;  // Supprime le successeur dans l'ordre if (succParent->left == succ) succParent->left = succ->right;  sinon succParent->right = succ->right;  gratuit (succès);  retourner la racine ; } // Driver Code int main() { /* Créons les suivants BST 50 /  30 70 /  /  20 40 60 80 */ struct Node* root = NULL;  racine = insert(racine, 50);  insert(racine, 30);  insert(racine, 20);  insert(racine, 40);  insert(racine, 70);  insert(racine, 60);  insert(racine, 80);  printf('BST d'origine : ');  dans l'ordre (racine);    printf('

Supprimer un nœud feuille : 20
');  racine = deleteNode (racine, 20);  printf('Arborescence BST modifiée après la suppression du nœud feuille :
');  dans l'ordre (racine);  printf('

Supprimer le nœud avec un seul enfant : 70
');  racine = deleteNode (racine, 70);  printf('Arborescence BST modifiée après la suppression d'un seul nœud enfant :
');  dans l'ordre (racine);  printf('

Supprimer le nœud avec les deux enfants : 50
');  racine = deleteNode (racine, 50);  printf('Arborescence BST modifiée après la suppression des deux nœuds enfants :
');  dans l'ordre (racine);  renvoie 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>node.key) { node.right = insert(node.right, clé);  } // renvoie le pointeur de nœud (inchangé) return node;  } // Une fonction utilitaire pour effectuer un parcours dans l'ordre de BST void inorder(Node root) { if (root != null) { inorder(root.left);  System.out.print(root.key + '');  dans l'ordre (root.right);  } } // Étant donné un arbre de recherche binaire et une clé, cette fonction supprime la clé et renvoie la nouvelle racine Node deleteNode(Node root, int key) { // Cas de base if (root == null) { return root;  } // Si la clé à supprimer est plus petite que la clé de la racine, alors elle se trouve dans le sous-arbre de gauche 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>root.key) { root.right = deleteNode(root.right, clé);  } // Si la clé est la même que celle de root, alors c'est le nœud à supprimer else { // Nœud avec un seul enfant ou aucun enfant if (root.left == null) { return root.right;  } else if (root.right == null) { return root.left;  } // Nœud avec deux enfants : récupère le successeur dans l'ordre (le plus petit dans le sous-arbre de droite) root.key = minValue(root.right);  // Supprime le successeur dans l'ordre root.right = deleteNode(root.right, root.key);  } renvoie la racine ;  } int minValue (racine du nœud) { int minv = root.key;  while (root.left != null) { minv = root.left.key;  root = root.left;  } retourne minv ;  } // Code du pilote public static void main(String[] args) { BinaryTree tree = new BinaryTree();  /* Créons suivant BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50);  arbre.insert(arbre.racine, 30);  arbre.insert(arbre.racine, 20);  arbre.insert(arbre.racine, 40);  arbre.insert(arbre.racine, 70);  arbre.insert(arbre.racine, 60);  arbre.insert(arbre.racine, 80);  System.out.print('BST original : ');  arbre.inorder(arbre.root);  System.out.println();  System.out.println('
Supprimer un nœud feuille : 20');  arbre.root = arbre.deleteNode(arbre.root, 20);  System.out.print('Arborescence BST modifiée après la suppression du nœud feuille :
');  arbre.inorder(arbre.root);  System.out.println();  System.out.println('
Supprimer le nœud avec un seul enfant : 70');  arbre.root = arbre.deleteNode(arbre.root, 70);  System.out.print('Arborescence BST modifiée après la suppression d'un seul nœud enfant :
');  arbre.inorder(arbre.root);  System.out.println();  System.out.println('
Supprimer le nœud avec les deux enfants : 50');  arbre.root = arbre.deleteNode(arbre.root, 50);  System.out.print('Arborescence BST modifiée après la suppression des deux nœuds enfants :
');  arbre.inorder(arbre.root);  } }>

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) # renvoie le pointeur de nœud (inchangé) return node # Une fonction utilitaire pour parcourir dans l'ordre BST def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # Étant donné un arbre de recherche binaire et une clé, cette fonction supprime la clé et renvoie la nouvelle racine def deleteNode (self, root, key) : # Cas de base si root est Aucun : return root # Si la clé à supprimer est plus petite que la clé de la racine, alors elle se trouve dans le sous-arbre de gauche si key< 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 clé est la même que celle de root, alors c'est le nœud à supprimer sinon : # Nœud avec un seul enfant ou aucun enfant si root.left est Aucun : return root.right elif root.right est Aucun : return root.left # Nœud avec deux enfants : Obtenez le successeur dans l'ordre (le plus petit dans le sous-arbre droit) root.key = self.minValue(root.right) # Supprimer le successeur dans l'ordre 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 # Code du pilote si __name__ == '__main__': tree = BinaryTree() # Créons le BST suivant # 50 # /  # 30 70 # /  /  # 20 40 60 80 tree.root = arbre.insert(arbre.racine, 50) arbre.insert(arbre.racine, 30) arbre.insert(arbre.racine, 20) arbre.insert(arbre.racine, 40) arbre.insert(arbre.racine, 70 ) tree.insert(tree.root, 60) tree.insert(tree.root, 80) print('Original BST:', end=' ') tree.inorder(tree.root) print() print ('
Supprimer un nœud feuille : 20') tree.root = tree.deleteNode(tree.root, 20) print('Arbre BST modifié après la suppression du nœud feuille :') tree.inorder(tree.root) print() print('
Delete Node with single child: 70') tree.root = tree.deleteNode(tree.root, 70) print('Arbre BST modifié après la suppression d'un seul enfant Node:') tree. inorder(tree.root) print() print('
Supprimer le nœud avec les deux enfants : 50') tree.root = tree.deleteNode(tree.root, 50) print('Arbre BST modifié après la suppression des deux nœuds enfants :') arbre.inorder(arbre.racine)>

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>node.key) node.right = Insérer (node.right, clé);  // renvoie le pointeur de nœud (inchangé) return node;  } // Une fonction utilitaire pour effectuer un parcours dans l'ordre de BST public void Inorder(Node root) { if (root != null) { Inorder(root.left);  Console.Write(root.key + ' ');  Dans l'ordre(root.right);  } } // Étant donné un arbre de recherche binaire et une clé, cette fonction supprime la clé et renvoie la nouvelle racine public Node DeleteNode(Node root, int key) { // Cas de base if (root == null) return root;  // Si la clé à supprimer est plus petite que la clé de la racine, alors elle se trouve dans le sous-arbre de gauche 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>root.key) root.right = SupprimerNode(root.right, clé);  // Si la clé est la même que la clé de root, alors c'est le nœud à supprimer else { // Nœud avec un seul enfant ou aucun enfant if (root.left == null) return root.right;  sinon, si (root.right == null) renvoie root.left ;  // Nœud avec deux enfants : récupère le successeur dans l'ordre (le plus petit dans le sous-arbre de droite) root.key = MinValue(root.right);  // Supprime le successeur dans l'ordre root.right = DeleteNode(root.right, root.key);  } renvoie la racine ;  } public int MinValue (racine du nœud) { int minv = root.key;  while (root.left != null) { minv = root.left.key;  root = root.left;  } retourne minv ;  } // Code du pilote public static void Main(string[] args) { BinaryTree tree = new BinaryTree();  /* Créons suivant BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.Insert(tree.root, 50);  arbre.Insert(arbre.racine, 30);  arbre.Insert(arbre.racine, 20);  arbre.Insert(arbre.racine, 40);  arbre.Insert(arbre.racine, 70);  arbre.Insert(arbre.root, 60);  arbre.Insert(arbre.root, 80);  Console.Write('BST d'origine : ');  arbre.Inorder(arbre.root);  Console.WriteLine();  Console.WriteLine('
Supprimer un nœud feuille : 20');  arbre.root = arbre.DeleteNode(arbre.root, 20);  Console.Write('Arborescence BST modifiée après la suppression du nœud feuille :
');  arbre.Inorder(arbre.root);  Console.WriteLine();  Console.WriteLine('
Supprimer le nœud avec un seul enfant : 70');  arbre.root = arbre.DeleteNode(arbre.root, 70);  Console.Write('Arborescence BST modifiée après la suppression d'un seul nœud enfant :
');  arbre.Inorder(arbre.root);  Console.WriteLine();  Console.WriteLine('
Supprimer le nœud avec les deux enfants : 50');  arbre.root = arbre.DeleteNode(arbre.root, 50);  Console.Write('Arborescence BST modifiée après la suppression des deux nœuds enfants :
');  arbre.Inorder(arbre.root);  }>

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>node.key) node.right = this.insert(node.right, key);  // renvoie le pointeur de nœud (inchangé) return node;  } // Une fonction utilitaire pour effectuer un parcours dans l'ordre de BST inorder(node) { if (node ​​!== null) { this.inorder(node.left);  console.log(node.key + '');  this.inorder(node.right);  } } // Étant donné un arbre de recherche binaire et une clé, cette fonction supprime la clé et renvoie la nouvelle racine deleteNode(root, key) { // Cas de base if (root === null) return root;  // Si la clé à supprimer est plus petite que la clé de la racine, alors elle se trouve dans le sous-arbre de gauche 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>root.key) root.right = this.deleteNode(root.right, key);  // Si la clé est la même que la clé de root, alors c'est le nœud à supprimer else { // Nœud avec un seul enfant ou aucun enfant if (root.left === null) return root.right;  sinon si (root.right === null) return root.left;  // Nœud avec deux enfants : récupère le successeur dans l'ordre (le plus petit dans le sous-arbre de droite) root.key = this.minValue(root.right);  // Supprime le successeur dans l'ordre root.right = this.deleteNode(root.right, root.key);  } renvoie la racine ;  } minValue(node) { let minv = node.key;  while (node.left !== null) { minv = node.left.key;  noeud = noeud.left;  } retourne minv ;  } } // Code du pilote let tree = new BinaryTree(); /* Créons suivant BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50); arbre.insert(arbre.racine, 30); arbre.insert(arbre.racine, 20); arbre.insert(arbre.racine, 40); arbre.insert(arbre.racine, 70); arbre.insert(arbre.racine, 60); arbre.insert(arbre.racine, 80); console.log('BST d'origine :'); arbre.inorder(arbre.root); console.log('

Supprimer un nœud feuille : 20'); arbre.root = arbre.deleteNode(arbre.root, 20); console.log('Arborescence BST modifiée après la suppression du nœud feuille :'); arbre.inorder(arbre.root); console.log('

Supprimer le nœud avec un seul enfant : 70'); arbre.root = arbre.deleteNode(arbre.root, 70); console.log('Arborescence BST modifiée après la suppression d'un seul nœud enfant :'); arbre.inorder(arbre.root); console.log('

Supprimer le nœud avec les deux enfants : 50'); arbre.root = arbre.deleteNode(arbre.root, 50); console.log('Arborescence BST modifiée après la suppression des deux nœuds enfants :'); arbre.inorder(arbre.root);>