#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->키 = 아이템;  온도->왼쪽 = 온도->오른쪽 = NULL;  복귀온도; } // BST의 중위 순회를 수행하는 유틸리티 함수 void inorder(Node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', 루트->키);  inorder(루트->오른쪽);  } } /* * BST에 주어진 키를 가진 새 노드를 삽입하는 유틸리티 함수 */ Node* insert(Node* node, int key) { /* 트리가 비어 있으면 새 노드를 반환 */ if (node ​​= = NULL) return newNode(key);  /* 그렇지 않으면 트리 아래로 반복 */ if (key< node->키) 노드->왼쪽 = insert(노드->왼쪽, 키);  else node->right = insert(노드->right, key);  /* (변경되지 않은) 노드 포인터를 반환합니다. */ return node; } /* 이진 검색 트리와 키가 주어지면 이 함수는 키를 삭제하고 새 루트를 반환합니다. */ Node* deleteNode(Node* root, int k) { // 기본 사례 if (root == NULL) return root;  // 삭제할 키가 루트의 키보다 작으면 // 왼쪽 하위 트리에 위치합니다. if (k< root->key) { root->left = deleteNode(root->left, k);  루트를 반환;  } // 삭제할 키가 루트의 키보다 크면 // 오른쪽 하위 트리에 놓입니다. else if (k> root->key) { root->right = deleteNode(root->right , k);  루트를 반환;  } // 키가 루트의 키와 동일하면 삭제될 노드입니다. // 자식이 하나만 있거나 자식이 없는 노드 if (root->left == NULL) { Node* temp = root-> 오른쪽;  루트 삭제;  복귀온도;  } else if (루트->오른쪽 == NULL) { 노드* 임시 = 루트->왼쪽;  루트 삭제;  복귀온도;  } // 두 개의 자식이 있는 노드: 중위 계승자를 얻습니다(오른쪽 하위 트리에서 가장 작은 //) Node* succParent = root;  노드* succ = 루트->오른쪽;  while (succ->left != NULL) { succParent = succ;  succ = succ->왼쪽;  } // 중위 계승자의 콘텐츠를 이 노드에 복사합니다. root->key = succ->key;  // 중위 후속자 삭제 if (succParent->left == succ) succParent->left = succ->right;  그렇지 않으면 succParent->right = succ->right;    삭제하세요.  루트를 반환; } // 드라이버 코드 int main() { /* 다음 BST를 생성하겠습니다. 50 /  30 70 /  /  20 40 60 80 */ Node* root = NULL;  루트 = 삽입(루트, 50);  루트 = 삽입(루트, 30);  루트 = 삽입(루트, 20);  루트 = 삽입(루트, 40);  루트 = 삽입(루트, 70);  루트 = 삽입(루트, 60);  루트 = 삽입(루트, 80);  printf('원본 BST: ');  중위(루트);    printf('

리프 노드 삭제: 20
');  루트 = deleteNode(루트, 20);  printf('리프 노드 삭제 후 수정된 BST 트리:
');  중위(루트);  printf('

단일 하위 항목이 있는 노드 삭제: 70
');  루트 = deleteNode(루트, 70);  printf('단일 하위 노드를 삭제한 후 수정된 BST 트리:
');  중위(루트);  printf('

두 자식이 모두 있는 노드 삭제: 50
');  루트 = deleteNode(루트, 50);  printf('두 하위 노드를 모두 삭제한 후 수정된 BST 트리:
');  중위(루트);  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->키 = 아이템;  온도->왼쪽 = 온도->오른쪽 = NULL;  복귀온도; } // BST의 중위 순회를 수행하는 유틸리티 함수 void inorder(struct Node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', 루트->키);  inorder(루트->오른쪽);  } } /* BST에 주어진 키를 사용하여 새 노드를 삽입하는 유틸리티 함수 */ struct Node* insert(struct Node* node, int key) { /* 트리가 비어 있으면 새 노드를 반환 */ if (node == NULL) return newNode(key);  /* 그렇지 않으면 트리 아래로 반복 */ if (key< node->키) 노드->왼쪽 = insert(노드->왼쪽, 키);  else node->right = insert(노드->right, key);  /* (변경되지 않은) 노드 포인터를 반환합니다. */ return node; } /* 이진 검색 트리와 키가 주어지면 이 함수는 키를 삭제하고 새 루트를 반환합니다. */ struct Node* deleteNode(struct Node* root, int k) { // 기본 사례 if (root == NULL) return 뿌리;  // 삭제할 키가 루트 키보다 작으면 왼쪽 하위 트리에 위치합니다. if (k< root->key) { root->left = deleteNode(root->left, k);  루트를 반환;  } // 삭제할 키가 루트의 키보다 크면 오른쪽 하위 트리에 위치합니다. else if (k> root->key) { root->right = deleteNode(root->right, k );  루트를 반환;  } // 키가 루트의 키와 동일하면 삭제될 노드입니다. // 자식이 하나만 있거나 자식이 없는 노드 if (root->left == NULL) { struct Node* temp = root-> 그렇죠;  무료(루트);  복귀온도;  } else if (root->right == NULL) { struct Node* temp = root->left;  무료(루트);  복귀온도;  } // 두 개의 자식이 있는 노드: 중위 후속자(오른쪽 하위 트리에서 가장 작은)를 가져옵니다. struct Node* succParent = root;  struct Node* succ = 루트->오른쪽;  while (succ->left != NULL) { succParent = succ;  succ = succ->왼쪽;  } // 중위 계승자의 콘텐츠를 이 노드에 복사합니다. root->key = succ->key;  // 중위 후속자 삭제 if (succParent->left == succ) succParent->left = succ->right;  그렇지 않으면 succParent->right = succ->right;  무료(succ);  루트를 반환; } // 드라이버 코드 int main() { /* 다음 BST를 생성하겠습니다. 50 /  30 70 /  /  20 40 60 80 */ struct Node* root = NULL;  루트 = 삽입(루트, 50);  insert(루트, 30);  insert(루트, 20);  insert(루트, 40);  insert(루트, 70);  insert(루트, 60);  insert(루트, 80);  printf('원본 BST: ');  중위(루트);    printf('

리프 노드 삭제: 20
');  루트 = deleteNode(루트, 20);  printf('리프 노드 삭제 후 수정된 BST 트리:
');  중위(루트);  printf('

단일 하위 항목이 있는 노드 삭제: 70
');  루트 = deleteNode(루트, 70);  printf('단일 하위 노드를 삭제한 후 수정된 BST 트리:
');  중위(루트);  printf('

두 자식이 모두 있는 노드 삭제: 50
');  루트 = deleteNode(루트, 50);  printf('두 하위 노드를 모두 삭제한 후 수정된 BST 트리:
');  중위(루트);  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, 키);  } // (변경되지 않은) 노드 포인터를 반환합니다. return node;  } // BST의 중위 순회를 수행하는 유틸리티 함수 void inorder(Node root) { if (root != null) { inorder(root.left);  System.out.print(root.key + ' ');  중위(root.right);  } } // 이진 검색 트리와 키가 주어지면 이 함수는 키를 삭제하고 새 루트 노드를 반환합니다. Node deleteNode(Node root, int key) { // 기본 사례 if (root == null) { return root;  } // 삭제할 키가 루트의 키보다 작으면 왼쪽 하위 트리에 위치합니다.< 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);  } // 키가 루트의 키와 동일하면 삭제될 노드입니다. else { // 자식이 하나만 있거나 자식이 없는 노드 if (root.left == null) { return root.right;  } else if (root.right == null) { return root.left;  } // 두 개의 자식이 있는 노드: 중위 후속자(오른쪽 하위 트리에서 가장 작은 값)를 가져옵니다. root.key = minValue(root.right);  // 중위 계승자 삭제 root.right = deleteNode(root.right, root.key);  } 루트를 반환합니다;  } int minValue(노드 루트) { int minv = root.key;  while (root.left != null) { minv = root.left.key;  루트 = 루트.왼쪽;  } minv를 반환합니다.  } // 드라이버 코드 public static void main(String[] args) { BinaryTree tree = new BinaryTree();  /* 다음과 같은 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('원본 BST: ');  tree.inorder(tree.root);  System.out.println();  System.out.println('
리프 노드 삭제: 20');  tree.root = tree.deleteNode(tree.root, 20);  System.out.print('리프 노드 삭제 후 수정된 BST 트리:
');  tree.inorder(tree.root);  System.out.println();  System.out.println('
단일 하위 항목이 있는 노드 삭제: 70');  tree.root = tree.deleteNode(tree.root, 70);  System.out.print('단일 하위 노드 삭제 후 수정된 BST 트리:
');  tree.inorder(tree.root);  System.out.println();  System.out.println('
두 하위 항목이 모두 있는 노드 삭제: 50');  tree.root = tree.deleteNode(tree.root, 50);  System.out.print('두 하위 노드 모두 삭제 후 수정된 BST 트리:
');  tree.inorder(tree.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) # (변경되지 않은) 노드 포인터를 반환 return node # BST의 중위 순회를 수행하는 유틸리티 함수 def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # 이진 검색 트리와 키가 주어지면 이 함수는 키를 삭제하고 새 루트를 반환합니다 def deleteNode (self, root, key): # 기본 사례 if root is None: return root # 삭제할 키가 루트의 키보다 작으면 왼쪽 하위 트리에 놓입니다. 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, key) # 키가 루트의 키와 동일하면 삭제될 노드입니다. else: # 자식이 하나만 있거나 자식이 없는 노드 if root.left is None: return root.right elif root.right is None: return root.left # 두 개의 자식이 있는 노드: 중위 계승자 가져오기(오른쪽 하위 트리에서 가장 작은 것) root.key = self.minValue(root.right) # 중위 계승자 삭제 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 # 드라이버 코드 if __name__ == '__main__': tree = BinaryTree() # 다음 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('원본 BST:', end=' ') tree.inorder(tree.root) print() 인쇄 ('
리프 노드 삭제: 20') tree.root = tree.deleteNode(tree.root, 20) print('리프 노드 삭제 후 수정된 BST 트리:') tree.inorder(tree.root) print() print('
단일 하위 노드가 있는 노드 삭제: 70') tree.root = tree.deleteNode(tree.root, 70) print('단일 하위 노드를 삭제한 후 수정된 BST 트리:') 트리. inorder(tree.root) print() print('
두 하위 노드 모두 삭제: 50') tree.root = tree.deleteNode(tree.root, 50) print('두 하위 노드를 모두 삭제한 후 수정된 BST 트리 :') 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(node.right, 키);  // (변경되지 않은) 노드 포인터를 반환합니다. return node;  } // BST의 중위 순회를 수행하는 유틸리티 함수 public void Inorder(Node root) { if (root != null) { Inorder(root.left);  Console.Write(root.key + ' ');  중순(root.right);  } } // 이진 검색 트리와 키가 주어지면 이 함수는 키를 삭제하고 새 루트를 반환합니다. public Node DeleteNode(Node root, int key) { // 기본 사례 if (root == null) return root;  // 삭제할 키가 루트 키보다 작으면 왼쪽 하위 트리에 위치합니다.< 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);  // 키가 루트의 키와 동일하면 삭제될 노드입니다. else { // 자식이 하나만 있거나 자식이 없는 노드 if (root.left == null) return root.right;  else if (root.right == null) return root.left;  // 두 개의 자식이 있는 노드: 중위 계승자(오른쪽 하위 트리에서 가장 작은 값)를 가져옵니다. root.key = MinValue(root.right);  // 중위 계승자를 삭제합니다. root.right = DeleteNode(root.right, root.key);  } 루트를 반환합니다.  } 공개 int MinValue(노드 루트) { int minv = root.key;  while (root.left != null) { minv = root.left.key;  루트 = 루트.왼쪽;  } minv를 반환합니다.  } // 드라이버 코드 public static void Main(string[] args) { BinaryTree tree = new BinaryTree();  /* 다음과 같은 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.Write('원본 BST: ');  tree.Inorder(tree.root);  Console.WriteLine();  Console.WriteLine('
리프 노드 삭제: 20');  tree.root = tree.DeleteNode(tree.root, 20);  Console.Write('리프 노드 삭제 후 수정된 BST 트리:
');  tree.Inorder(tree.root);  Console.WriteLine();  Console.WriteLine('
단일 하위 항목이 있는 노드 삭제: 70');  tree.root = tree.DeleteNode(tree.root, 70);  Console.Write('단일 하위 노드를 삭제한 후 수정된 BST 트리:
');  tree.Inorder(tree.root);  Console.WriteLine();  Console.WriteLine('
두 하위 항목이 모두 있는 노드 삭제: 50');  tree.root = tree.DeleteNode(tree.root, 50);  Console.Write('두 하위 노드를 모두 삭제한 후 수정된 BST 트리:
');  tree.Inorder(tree.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);  // (변경되지 않은) 노드 포인터를 반환합니다. return node;  } // BST의 중위 순회를 수행하는 유틸리티 함수 inorder(node) { if (node ​​!== null) { this.inorder(node.left);  console.log(node.key + ' ');  this.inorder(node.right);  } } // 이진 검색 트리와 키가 주어지면 이 함수는 키를 삭제하고 새 루트를 반환합니다. deleteNode(root, key) { // 기본 사례 if (root === null) return root;  // 삭제할 키가 루트의 키보다 작으면 왼쪽 하위 트리에 위치합니다.< 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);  // 키가 루트의 키와 동일하면 삭제될 노드입니다. else { // 자식이 하나만 있거나 자식이 없는 노드 if (root.left === null) return root.right;  else if (root.right === null) return root.left;  // 두 개의 자식이 있는 노드: 중위 계승자(오른쪽 하위 트리에서 가장 작은 값)를 가져옵니다. root.key = this.minValue(root.right);  // 중위 계승자 삭제 root.right = this.deleteNode(root.right, root.key);  } 루트를 반환합니다.  } minValue(노드) { minv = node.key;  while (node.left !== null) { minv = node.left.key;  노드 = node.left;  } minv를 반환합니다.  } } // 드라이버 코드 let tree = new BinaryTree(); /* 다음과 같은 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('원본 BST:'); tree.inorder(tree.root); console.log('

리프 노드 삭제: 20'); tree.root = tree.deleteNode(tree.root, 20); console.log('리프 노드 삭제 후 수정된 BST 트리:'); tree.inorder(tree.root); console.log('

단일 하위 항목이 있는 노드 삭제: 70'); tree.root = tree.deleteNode(tree.root, 70); console.log('단일 하위 노드 삭제 후 수정된 BST 트리:'); tree.inorder(tree.root); console.log('

두 하위 항목이 모두 있는 노드 삭제: 50'); tree.root = tree.deleteNode(tree.root, 50); console.log('두 하위 노드 모두 삭제 후 수정된 BST 트리:'); tree.inorder(tree.root);>