#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->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Pomocná funkce pro procházení BST podle pořadí void inorder(Uzel* root) { if (kořen != NULL) { inorder(kořen->vlevo);  printf('%d ', root->key);  inorder(kořen->vpravo);  } } /* Obslužná funkce pro vložení nového uzlu s daným klíčem do * BST */ Node* insert(Node* node, int key) { /* Pokud je strom prázdný, vrátí nový uzel */ if (node ​​= = NULL) return newNode(key);  /* V opačném případě se ve stromu opakujte */ if (key< node->key) node->left = insert(uzel->left, key);  else uzel->vpravo = insert(uzel->vpravo, klíč);  /* vrátí (nezměněný) ukazatel na uzel */ return uzel; } /* Vzhledem k binárnímu vyhledávacímu stromu a klíči tato funkce vymaže klíč a vrátí nový kořen */ Uzel* deleteNode(Uzel* root, int k) { // Základní případ if (kořen == NULL) return root;  // Pokud je klíč, který se má odstranit, menší než kořenový klíč, // pak leží v levém podstromu if (k< root->klíč) { root->left = deleteNode(root->left, k);  návratový kořen;  } // Pokud je klíč, který se má odstranit, větší než kořenový klíč, // pak leží v pravém podstromu else if (k> root->key) { root->right = deleteNode(root->right , k);  vrátit kořen;  } // Pokud je klíč stejný jako klíč root, pak toto je uzel, který má být odstraněn // Uzel s pouze jedním potomkem nebo bez potomka if (root->left == NULL) { Node* temp = root-> že jo;  odstranit kořen;  návratová teplota;  } else if (root->right == NULL) { Node* temp = root->left;  odstranit kořen;  návratová teplota;  } // Uzel se dvěma potomky: Získá následníka pořadí (nejmenší // v pravém podstromu) Uzel* succParent = root;  Uzel* succ = root->right;  while (succ->left != NULL) { succParent = succ;  succ = succ->vlevo;  } // Zkopírujte obsah následníka pořadí do tohoto uzlu root->key = succ->key;  // Smaže následníka pořadí if (succParent->left == succ) succParent->left = succ->right;  else succParent->right = succ->right;    smazat succ;  vrátit kořen; } // Kód ovladače int main() { /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ Node* root = NULL;  root = insert(root, 50);  root = insert(kořen, 30);  root = insert(kořen, 20);  root = insert(kořen, 40);  root = insert(kořen, 70);  root = insert(root, 60);  root = insert(kořen, 80);  printf('Původní BST: ');  inorder(kořen);    printf('

Smazat listový uzel: 20
');  root = deleteNode(kořen, 20);  printf('Upravený strom BST po smazání listového uzlu:
');  inorder(kořen);  printf('

Odstranit uzel s jedním potomkem: 70
');  root = deleteNode(kořen, 70);  printf('Upravený strom BST po smazání jednoho podřízeného uzlu:
');  inorder(kořen);  printf('

Odstranit uzel s oběma potomky: 50
');  root = deleteNode(kořen, 50);  printf('Upravený strom BST po smazání obou podřízených uzlů:
');  inorder(kořen);  návrat 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->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Pomocná funkce pro procházení BST podle pořadí void inorder(struct Node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', root->key);  inorder(kořen->vpravo);  } } /* Obslužná funkce pro vložení nového uzlu s daným klíčem v BST */ struct Node* insert(struct Node* uzel, klíč int) { /* Pokud je strom prázdný, vrátí nový uzel */ if (node == NULL) return newNode(key);  /* V opačném případě se ve stromu opakujte */ if (key< node->key) node->left = insert(uzel->left, key);  else uzel->vpravo = insert(uzel->vpravo, klíč);  /* vrátí (nezměněný) ukazatel na uzel */ return uzel; } /* Vzhledem k binárnímu vyhledávacímu stromu a klíči tato funkce vymaže klíč a vrátí nový kořen */ struct Node* deleteNode(struct Node* root, int k) { // Základní případ if (root == NULL) return vykořenit;  // Pokud je klíč, který má být odstraněn, menší než kořenový klíč, pak leží v levém podstromu if (k< root->klíč) { root->left = deleteNode(root->left, k);  návratový kořen;  } // Pokud je klíč k odstranění větší než kořenový klíč, pak leží v pravém podstromu else if (k> root->key) { root->right = deleteNode(root->right, k );  vrátit kořen;  } // Pokud je klíč stejný jako klíč root, pak toto je uzel, který má být odstraněn // Uzel s pouze jedním potomkem nebo žádným potomkem if (root->left == NULL) { struct Node* temp = root->pravý;  volný(kořen);  návratová teplota;  } else if (kořen->vpravo == NULL) { struct Node* temp = root->left;  volný(kořen);  návratová teplota;  } // Uzel se dvěma potomky: Získání následníka pořadí (nejmenší v pravém podstromu) struct Node* succParent = root;  struct Node* succ = root->right;  while (succ->left != NULL) { succParent = succ;  succ = succ->vlevo;  } // Zkopírujte obsah následníka pořadí do tohoto uzlu root->key = succ->key;  // Smaže následníka pořadí if (succParent->left == succ) succParent->left = succ->right;  else succParent->right = succ->right;  volný(succ);  vrátit kořen; } // Kód ovladače int main() { /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ struct Node* root = NULL;  root = insert(root, 50);  insert(kořen, 30);  insert(kořen, 20);  insert(kořen, 40);  insert(kořen, 70);  insert(kořen, 60);  insert(kořen, 80);  printf('Původní BST: ');  inorder(kořen);    printf('

Smazat listový uzel: 20
');  root = deleteNode(kořen, 20);  printf('Upravený strom BST po smazání listového uzlu:
');  inorder(kořen);  printf('

Odstranit uzel s jedním potomkem: 70
');  root = deleteNode(kořen, 70);  printf('Upravený strom BST po smazání jednoho podřízeného uzlu:
');  inorder(kořen);  printf('

Odstranit uzel s oběma potomky: 50
');  root = deleteNode(kořen, 50);  printf('Upravený strom BST po smazání obou podřízených uzlu:
');  inorder(kořen);  návrat 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(uzel.right, key);  } // vrátí (nezměněný) ukazatel na uzel return uzel;  } // Obslužná funkce pro procházení BST podle pořadí void inorder(kořen uzlu) { if (kořen != null) { inorder(kořen.left);  System.out.print(root.key + ' ');  inorder(root.right);  } } // Vzhledem k binárnímu vyhledávacímu stromu a klíči tato funkce vymaže klíč a vrátí nový kořen Uzel deleteNode(kořen uzlu, klíč int) { // Základní případ if (kořen == null) { return root;  } // Pokud je klíč, který se má odstranit, menší než kořenový klíč, pak leží v levém podstromu if (klíč< 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, key);  } // Je-li klíč stejný jako klíč root, pak toto je uzel, který má být odstraněn else { // Uzel s pouze jedním potomkem nebo bez potomka if (root.left == null) { return root.right;  } else if (root.right == null) { return root.left;  } // Uzel se dvěma potomky: Získání následníka pořadí (nejmenší v pravém podstromu) root.key = minValue(root.right);  // Smazání následníka pořadí root.right = deleteNode(root.right, root.key);  } return root;  } int minValue(kořen uzlu) { int minv = kořen.klíč;  while (root.left != null) { minv = root.left.key;  kořen = kořen.vlevo;  } return minv;  } // Kód ovladače public static void main(String[] args) { BinaryTree tree = new BinaryTree();  /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50);  tree.insert(strom.kořen, 30);  tree.insert(strom.kořen, 20);  tree.insert(strom.kořen, 40);  tree.insert(strom.kořen, 70);  tree.insert(strom.kořen, 60);  tree.insert(strom.kořen, 80);  System.out.print('Původní BST: ');  tree.inorder(strom.kořen);  System.out.println();  System.out.println('
Smazat listový uzel: 20');  tree.root = tree.deleteNode(tree.root, 20);  System.out.print('Upravený strom BST po smazání listového uzlu:
');  tree.inorder(strom.kořen);  System.out.println();  System.out.println('
Smazat uzel s jedním potomkem: 70');  tree.root = tree.deleteNode(tree.root, 70);  System.out.print('Upravený strom BST po smazání jednoho podřízeného uzlu:
');  tree.inorder(strom.kořen);  System.out.println();  System.out.println('
Odstranit uzel s oběma potomky: 50');  tree.root = tree.deleteNode(strom.kořen, 50);  System.out.print('Změněný strom BST po smazání obou podřízených Node:
');  tree.inorder(strom.kořen);  } }>

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) # return the (nezměněný) uzel pointer return node # Užitečná funkce k provedení procházení BST podle pořadí def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # Vzhledem k binárnímu vyhledávacímu stromu a klíči tato funkce vymaže klíč a vrátí nový kořenový def deleteNode (self, root, key): # Základní případ, pokud je root Žádný: návrat root # Pokud je klíč, který má být odstraněn, menší než klíč root, pak leží v levém podstromu if 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, klíč) # Pokud je klíč stejný jako klíč root, pak toto je uzel, který má být odstraněn jinak: # Uzel s pouze jedním potomkem nebo bez potomka, pokud root.left is None: return root.right elif root.right is None: return root.left # Uzel se dvěma potomky: Získejte následníka pořadí (nejmenší v pravém podstromu) root.key = self.minValue(root.right) # Smazat následníka pořadí 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 # Driver Code if __name__ == '__main__': tree = BinaryTree() # Vytvořme následující BST # 50 # /  # 30 70 # /  /  # 20 40 60 80 tree.root = tree.insert(strom.root, 50) tree.insert(tree.root, 30) tree.insert(tree.root, 20) tree.insert(tree.root, 40) tree.insert(tree.root, 70) ) tree.insert(strom.root, 60) tree.insert(tree.root, 80) print('Original BST:', end=' ') tree.inorder(tree.root) print() print ('
Smazat listový uzel: 20') tree.root = tree.deleteNode(tree.root, 20) print('Upravený strom BST po smazání listového uzlu:') tree.inorder(tree.root) print() print('
Smazat uzel s jedním potomkem: 70') tree.root = tree.deleteNode(tree.root, 70) print('Upravený strom BST po smazání jednoho potomka Node:') strom. inorder(strom.kořen) print() print('
Smazat uzel s oběma podřízenými uzly: 50') tree.root = tree.deleteNode(strom.kořen, 50) print('Upravený strom BST po smazání obou podřízených uzlu :') tree.inorder(tree.root)>

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 = Insert(uzel.right, key);  // vrátí (nezměněný) ukazatel uzlu return node;  } // Obslužná funkce pro procházení BST public void Inorder(kořen uzlu) { if (root != null) { Inorder(root.left);  Console.Write(root.key + ' ');  Inorder(root.right);  } } // Vzhledem k binárnímu vyhledávacímu stromu a klíči tato funkce vymaže klíč a vrátí nový kořen public Node DeleteNode(kořen uzlu, klíč int) { // Základní případ if (root == null) return root;  // Pokud je klíč, který se má odstranit, menší než kořenový klíč, pak leží v levém podstromu if (klíč< 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, key);  // Pokud je klíč stejný jako klíč root, pak se jedná o uzel, který má být odstraněn else { // Uzel s pouze jedním potomkem nebo bez potomka if (root.left == null) return root.right;  else if (root.right == null) return root.left;  // Uzel se dvěma potomky: Získá následníka pořadí (nejmenší v pravém podstromu) root.key = MinValue(root.right);  // Smazání následníka pořadí root.right = DeleteNode(root.right, root.key);  } return root;  } public int MinValue(kořen uzlu) { int minv = root.key;  while (root.left != null) { minv = root.left.key;  kořen = kořen.vlevo;  } return minv;  } // Kód ovladače public static void Main(string[] args) { BinaryTree tree = new BinaryTree();  /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.Insert(tree.root, 50);  tree.Insert(strom.kořen, 30);  tree.Insert(strom.kořen, 20);  tree.Insert(strom.kořen, 40);  tree.Insert(strom.kořen, 70);  tree.Insert(strom.kořen, 60);  tree.Insert(strom.kořen, 80);  Console.Write('Původní BST: ');  strom.Inorder(strom.kořen);  Console.WriteLine();  Console.WriteLine('
Smazat listový uzel: 20');  tree.root = tree.DeleteNode(tree.root, 20);  Console.Write('Upravený strom BST po smazání listového uzlu:
');  strom.Inorder(strom.kořen);  Console.WriteLine();  Console.WriteLine('
Smazat uzel s jedním potomkem: 70');  tree.root = tree.DeleteNode(tree.root, 70);  Console.Write('Upravený strom BST po odstranění jednoho podřízeného uzlu:
');  strom.Inorder(strom.kořen);  Console.WriteLine();  Console.WriteLine('
Odstranit uzel s oběma potomky: 50');  tree.root = tree.DeleteNode(tree.root, 50);  Console.Write('Upravený strom BST po smazání obou podřízených uzlu:
');  strom.Inorder(strom.kořen);  }>

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(uzel.right, key);  // vrátí (nezměněný) ukazatel uzlu return node;  } // Obslužná funkce pro procházení BST inorder(node) { if (node ​​!== null) { this.inorder(node.left);  console.log(node.key + ' ');  this.inorder(uzel.right);  } } // Vzhledem k binárnímu vyhledávacímu stromu a klíči tato funkce vymaže klíč a vrátí nový kořen deleteNode(root, key) { // Základní případ if (root === null) return root;  // Pokud je klíč, který se má odstranit, menší než kořenový klíč, pak leží v levém podstromu if (klíč< 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);  // Pokud je klíč stejný jako klíč root, pak se jedná o uzel, který má být odstraněn else { // Uzel s pouze jedním potomkem nebo bez potomka if (root.left === null) return root.right;  else if (root.right === null) return root.left;  // Uzel se dvěma potomky: Získá následníka pořadí (nejmenší v pravém podstromu) root.key = this.minValue(root.right);  // Smazání následníka pořadí root.right = this.deleteNode(root.right, root.key);  } return root;  } minValue(uzel) { let minv = uzel.klíč;  while (node.left !== null) { minv = node.left.key;  uzel = uzel.vlevo;  } return minv;  } } // Kód ovladače let tree = new BinaryTree(); /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50); tree.insert(strom.kořen, 30); tree.insert(strom.kořen, 20); tree.insert(strom.kořen, 40); tree.insert(strom.kořen, 70); tree.insert(strom.kořen, 60); tree.insert(strom.kořen, 80); console.log('Původní BST:'); tree.inorder(strom.kořen); console.log('

Smazat listový uzel: 20'); tree.root = tree.deleteNode(strom.kořen, 20); console.log('Upravený strom BST po smazání listového uzlu:'); tree.inorder(strom.kořen); console.log('

Odstranit uzel s jedním potomkem: 70'); tree.root = tree.deleteNode(strom.kořen, 70); console.log('Upravený strom BST po smazání jednoho podřízeného uzlu:'); tree.inorder(strom.kořen); console.log('

Odstranit uzel s oběma potomky: 50'); tree.root = tree.deleteNode(strom.kořen, 50); console.log('Upravený strom BST po smazání obou podřízených uzlů:'); tree.inorder(strom.kořen);>