#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->kľúč = položka;  temp->left = temp->right = NULL;  návratová teplota; } // Pomocná funkcia na vykonanie prechodu BST podľa poradia void inorder(Node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', root->key);  inorder(root->right);  } } /* Pomocná funkcia na vloženie nového uzla s daným kľúčom do * BST */ Node* insert(Node* node, int key) { /* Ak je strom prázdny, vráti nový uzol */ if (node ​​= = NULL) return newNode(key);  /* V opačnom prípade sa zopakujte v strome */ if (key< node->key) node->left = insert(uzol->left, key);  else uzol->vpravo = vložiť(uzol->vpravo, kľúč);  /* vráti (nezmenený) ukazovateľ uzla */ return node; } /* Daný binárny vyhľadávací strom a kľúč, táto funkcia vymaže kľúč a vráti nový koreň */ Node* deleteNode(Node* root, int k) { // Základný prípad if (root == NULL) return root;  // Ak je kľúč, ktorý sa má odstrániť, menší ako koreňový kľúč, // potom leží v ľavom podstrome, ak (k< root->kľúč) { root->left = deleteNode(root->left, k);  vrátiť koreň;  } // Ak je kľúč, ktorý sa má odstrániť, väčší ako koreňový kľúč, // potom leží v pravom podstrome else if (k> root->key) { root->right = deleteNode(root->right , k);  vrátiť koreň;  } // Ak je kľúč rovnaký ako kľúč root, potom toto je uzol, ktorý sa má odstrániť // Uzol s iba jedným potomkom alebo bez potomka if (root->left == NULL) { Node* temp = root-> správny;  odstrániť root;  návratová teplota;  } else if (root->right == NULL) { Node* temp = root->left;  odstrániť root;  vratná teplota;  } // Uzol s dvoma potomkami: Získa nástupcu poradia (najmenší // v pravom podstrome) Uzol* succParent = root;  Uzol* succ = root->right;  while (succ->left != NULL) { succParent = succ;  succ = succ->vľavo;  } // Skopírujte obsah následníka poradia do tohto uzla root->key = succ->key;  // Zmazať následníka poradia if (succParent->left == succ) succParent->left = succ->right;  else succParent->right = succ->right;    vymazať succ;  vrátiť koreň; } // Kód ovládača int main() { /* Vytvorme nasledujúci BST 50 /  30 70 /  /  20 40 60 80 */ Node* root = NULL;  root = insert(root, 50);  root = insert(root, 30);  root = insert(root, 20);  root = insert(root, 40);  root = insert(root, 70);  root = insert(root, 60);  root = insert(root, 80);  printf('Pôvodný BST: ');  inorder(koreň);    printf('

Odstrániť listový uzol: 20
');  root = deleteNode(root, 20);  printf('Upravený strom BST po odstránení listového uzla:
');  inorder(koreň);  printf('

Odstrániť uzol s jedným potomkom: 70
');  root = deleteNode(root, 70);  printf('Upravený strom BST po odstránení jedného podriadeného uzla:
');  inorder(koreň);  printf('

Odstrániť uzol s oboma potomkami: 50
');  root = deleteNode(root, 50);  printf('Upravený strom BST po odstránení oboch dcérskych uzlov:
');  inorder(koreň);  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->kľúč = položka;  temp->left = temp->right = NULL;  vratná teplota; } // Pomocná funkcia na vykonanie prechodu BST podľa poradia void inorder(struct Node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', root->key);  inorder(root->right);  } } /* Pomocná funkcia na vloženie nového uzla s daným kľúčom v BST */ struct Node* insert(struct Node* node, int key) { /* Ak je strom prázdny, vráti nový uzol */ if (node == NULL) return newNode(key);  /* V opačnom prípade sa zopakujte v strome */ if (key< node->key) node->left = insert(uzol->left, key);  else uzol->vpravo = vložiť(uzol->vpravo, kľúč);  /* vráti (nezmenený) ukazovateľ uzla */ return node; } /* Vzhľadom na binárny vyhľadávací strom a kľúč táto funkcia vymaže kľúč a vráti nový koreň */ struct Node* deleteNode(struct Node* root, int k) { // Základný prípad if (root == NULL) return koreň;  // Ak je kľúč, ktorý sa má odstrániť, menší ako koreňový kľúč, potom leží v ľavom podstrome, ak (k< root->kľúč) { root->left = deleteNode(root->left, k);  vrátiť koreň;  } // Ak je kľúč, ktorý sa má odstrániť, väčší ako koreňový kľúč, potom leží v pravom podstrome else if (k> root->key) { root->right = deleteNode(root->right, k );  vrátiť koreň;  } // Ak je kľúč rovnaký ako kľúč root, potom toto je uzol, ktorý sa má odstrániť // Uzol s iba jedným potomkom alebo bez potomka if (root->left == NULL) { struct Node* temp = root->vpravo;  free(root);  návratová teplota;  } else if (root->vpravo == NULL) { struct Node* temp = root->left;  free(root);  návratová teplota;  } // Uzol s dvoma potomkami: Získame nástupcu poradia (najmenší v pravom podstrome) struct Node* succParent = root;  struct Node* succ = root->right;  while (succ->left != NULL) { succParent = succ;  succ = succ->vľavo;  } // Skopírujte obsah následníka poradia do tohto uzla root->key = succ->key;  // Zmazať následníka poradia if (succParent->left == succ) succParent->left = succ->right;  else succParent->right = succ->right;  free(succ);  vrátiť koreň; } // Kód ovládača int main() { /* Vytvorme nasledujúci BST 50 /  30 70 /  /  20 40 60 80 */ struct Node* root = NULL;  root = insert(root, 50);  vložiť(koreň, 30);  vložiť(koreň, 20);  vložiť(koreň, 40);  vložiť(koreň, 70);  vložiť(koreň, 60);  vložiť(koreň, 80);  printf('Pôvodný BST: ');  inorder(koreň);    printf('

Odstrániť listový uzol: 20
');  root = deleteNode(root, 20);  printf('Upravený strom BST po odstránení listového uzla:
');  inorder(koreň);  printf('

Odstrániť uzol s jedným potomkom: 70
');  root = deleteNode(root, 70);  printf('Upravený strom BST po odstránení jedného podriadeného uzla:
');  inorder(koreň);  printf('

Odstrániť uzol s oboma potomkami: 50
');  root = deleteNode(root, 50);  printf('Upravený strom BST po odstránení oboch dcérskych uzlov:
');  inorder(koreň);  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>uzol.kľúč) { uzol.vpravo = vložiť(uzol.vpravo, kľúč);  } // vráti (nezmenený) ukazovateľ uzla návratový uzol;  } // Pomocná funkcia na vykonanie prechodu BST podľa poradia void inorder(koreň uzla) { if (root != null) { inorder(root.left);  System.out.print(root.key + ' ');  inorder(root.right);  } } // Vzhľadom na binárny vyhľadávací strom a kľúč táto funkcia vymaže kľúč a vráti nový koreňový uzol deleteNode(koreň uzla, kľúč int) { // Základný prípad if (root == null) { return root;  } // Ak je kľúč, ktorý sa má odstrániť, menší ako koreňový kľúč, potom leží v ľavom podstrome if (kľúč< 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);  } // Ak je kľúč rovnaký ako kľúč root, potom toto je uzol, ktorý sa má odstrániť else { // Uzol s iba jedným potomkom alebo bez potomka if (root.left == null) { return root.right;  } else if (root.right == null) { return root.left;  } // Uzol s dvoma potomkami: Získame nástupcu poradia (najmenší v pravom podstrome) root.key = minValue(root.right);  // Vymazanie následníka poradia root.right = deleteNode(root.right, root.key);  } return root;  } int minValue(koreň uzla) { int minv = root.key;  while (root.left != null) { minv = root.left.key;  koreň = koreň.ľavý;  } return minv;  } // Kód ovládača public static void main(String[] args) { BinaryTree tree = new BinaryTree();  /* Vytvorme nasledujúci BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50);  tree.insert(tree.root, 30);  tree.insert(tree.root, 20);  tree.insert(tree.root, 40);  tree.insert(tree.root, 70);  tree.insert(tree.root, 60);  tree.insert(tree.root, 80);  System.out.print('Pôvodný BST: ');  tree.inorder(tree.root);  System.out.println();  System.out.println('
Odstrániť listový uzol: 20');  tree.root = tree.deleteNode(tree.root, 20);  System.out.print('Upravený strom BST po odstránení listového uzla:
');  tree.inorder(tree.root);  System.out.println();  System.out.println('
Odstrániť uzol s jedným potomkom: 70');  tree.root = tree.deleteNode(tree.root, 70);  System.out.print('Upravený strom BST po odstránení jedného podriadeného uzla:
');  tree.inorder(strom.koreň);  System.out.println();  System.out.println('
Odstrániť uzol s oboma potomkami: 50');  tree.root = tree.deleteNode(tree.root, 50);  System.out.print('Upravený strom BST po odstránení oboch dcérskych uzlov:
');  tree.inorder(strom.koreň);  } }>

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) # návrat (nezmenený) ukazovateľ uzla návrat node # Pomocná funkcia na vykonanie prechodu BST podľa poradia def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # Vzhľadom na binárny vyhľadávací strom a kľúč táto funkcia vymaže kľúč a vráti nový koreň def deleteNode (self, root, key): # Základný prípad, ak root je None: return root # Ak je kľúč, ktorý sa má vymazať, menší ako kľúč root, potom leží v ľavom podstrome if kľúč< 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, kľúč) # Ak je kľúč rovnaký ako kľúč root, potom je to uzol, ktorý sa má odstrániť inak: # Uzol s iba jedným potomkom alebo bez potomka, ak root.left is None: return root.right elif root.right is None: return root.left # Uzol s dvoma potomkami: Získajte nástupcu poradia (najmenší v pravom podstrome) root.key = self.minValue(root.right) # Odstrániť zaradeného následníka 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() # Vytvorme nasledujúci BST # 50 # /  # 30 70 # /  /  # 20 40 60 80 tree.root = tree.insert(tree.root, 50) tree.insert(tree.root, 30) tree.insert(tree.root, 20) tree.insert(tree.root, 40) tree.insert(tree.root, 70 ) tree.insert(tree.root, 60) tree.insert(tree.root, 80) print('Original BST:', end=' ') tree.inorder(tree.root) print() print ('
Odstrániť listový uzol: 20') tree.root = tree.deleteNode(tree.root, 20) print('Upravený strom BST po odstránení listového uzla:') tree.inorder(tree.root) print() print('
Odstrániť uzol s jedným potomkom: 70') tree.root = tree.deleteNode(tree.root, 70) print('Upravený strom BST po odstránení jedného potomka uzla:') strom. inorder(strom.root) print() print('
Odstrániť uzol s oboma potomkami: 50') tree.root = tree.deleteNode(strom.koreň, 50) print('Upravený strom BST po odstránení oboch dcérskych uzlov :') 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(uzol.right, key);  // vráti (nezmenený) ukazovateľ uzla return node;  } // Pomocná funkcia na vykonanie prechodu BST public void Inorder(koreň uzla) { if (root != null) { Inorder(root.left);  Console.Write(root.key + ' ');  Inorder(root.right);  } } // Vzhľadom na binárny vyhľadávací strom a kľúč táto funkcia vymaže kľúč a vráti nový koreňový verejný uzol DeleteNode (koreň uzla, kľúč int) { // Základný prípad if (root == null) return root;  // Ak je kľúč, ktorý sa má odstrániť, menší ako koreňový kľúč, potom leží v ľavom podstrome if (kľúč< 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);  // Ak je kľúč rovnaký ako kľúč root, potom toto je uzol, ktorý sa má odstrániť else { // Uzol s iba jedným potomkom alebo bez potomka if (root.left == null) return root.right;  else if (root.right == null) return root.left;  // Uzol s dvoma potomkami: Získa nástupcu poradia (najmenší v pravom podstrome) root.key = MinValue(root.right);  // Vymazanie následníka poradia root.right = DeleteNode(root.right, root.key);  } return root;  } public int MinHodnota(koreň uzla) { int minv = root.key;  while (root.left != null) { minv = root.left.key;  koreň = koreň.ľavý;  } return minv;  } // Kód ovládača public static void Main(string[] args) { BinaryTree tree = new BinaryTree();  /* Vytvorme nasledujúci BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.Insert(tree.root, 50);  strom.Vložiť(koreň stromu, 30);  strom.Vložiť(koreň stromu, 20);  strom.Vložiť(koreň stromu, 40);  strom.Vložiť(koreň stromu, 70);  strom.Vložiť(koreň stromu, 60);  strom.Insert(koreň stromu, 80);  Console.Write('Pôvodný BST: ');  strom.Inorder(strom.koreň);  Console.WriteLine();  Console.WriteLine('
Odstrániť listový uzol: 20');  tree.root = tree.DeleteNode(tree.root, 20);  Console.Write('Upravený strom BST po odstránení listového uzla:
');  strom.Inorder(strom.koreň);  Console.WriteLine();  Console.WriteLine('
Odstrániť uzol s jedným potomkom: 70');  tree.root = tree.DeleteNode(tree.root, 70);  Console.Write('Upravený strom BST po odstránení jedného podriadeného uzla:
');  strom.Inorder(strom.koreň);  Console.WriteLine();  Console.WriteLine('
Odstrániť uzol s oboma potomkami: 50');  tree.root = tree.DeleteNode(tree.root, 50);  Console.Write('Upravený strom BST po odstránení oboch dcérskych uzlov:
');  strom.Inorder(strom.koreň);  }>

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(uzol.right, key);  // vráti (nezmenený) ukazovateľ uzla return node;  } // Pomocná funkcia na vykonanie prechodu BST inorder(node) { if (node ​​!== null) { this.inorder(node.left);  console.log(node.key + ' ');  this.inorder(node.right);  } } // Vzhľadom na binárny vyhľadávací strom a kľúč táto funkcia vymaže kľúč a vráti nový koreň deleteNode(root, key) { // Základný prípad if (root === null) return root;  // Ak je kľúč, ktorý sa má odstrániť, menší ako koreňový kľúč, potom leží v ľavom podstrome if (kľúč< 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);  // Ak je kľúč rovnaký ako kľúč root, potom toto je uzol, ktorý sa má odstrániť else { // Uzol s iba jedným potomkom alebo bez potomka if (root.left === null) return root.right;  else if (root.right === null) return root.left;  // Uzol s dvoma potomkami: Získa nástupcu poradia (najmenší v pravom podstrome) root.key = this.minValue(root.right);  // Vymazanie následníka poradia root.right = this.deleteNode(root.right, root.key);  } return root;  } minValue(uzol) { nech minv = uzol.kľúč;  while (node.left !== null) { minv = node.left.key;  uzol = uzol.vľavo;  } return minv;  } } // Kód ovládača nech strom = new BinaryTree(); /* Vytvorme nasledujúci BST 50 /  30 70 /  /  20 40 60 80 */ tree.root = tree.insert(tree.root, 50); tree.insert(tree.root, 30); tree.insert(tree.root, 20); tree.insert(tree.root, 40); tree.insert(tree.root, 70); tree.insert(tree.root, 60); tree.insert(tree.root, 80); console.log('Pôvodný BST:'); tree.inorder(tree.root); console.log('

Odstrániť listový uzol: 20'); tree.root = tree.deleteNode(tree.root, 20); console.log('Upravený strom BST po odstránení Leaf Node:'); tree.inorder(strom.koreň); console.log('

Odstrániť uzol s jedným potomkom: 70'); tree.root = tree.deleteNode(tree.root, 70); console.log('Upravený strom BST po odstránení jedného podriadeného uzla:'); tree.inorder(strom.koreň); console.log('

Odstrániť uzol s oboma potomkami: 50'); tree.root = tree.deleteNode(tree.root, 50); console.log('Upravený strom BST po odstránení oboch dcérskych uzlov:'); tree.inorder(strom.koreň);>