// Use any below method to implement Nodes of tree // Method 1: Using 'struct' to make // user-define data type struct node {  int data;  struct node* left;  struct node* right; }; // Method 2: Using 'class' to make // user-define data type class Node { public:  int data;  Node* left;  Node* right; }; 

// Structure of each node of the tree struct node {  int data;  struct node* left;  struct node* right; }; 

// Class containing left and right child // of current node and key value class Node {  int key;  Node left, right;  public Node(int item)  {  key = item;  left = right = null;  } } 

# A Python class that represents # an individual node in a Binary Tree class Node: def __init__(self, key): self.left = None self.right = None self.val = key 

// Class containing left and right child // of current node and key value class Node {  int key;  Node left, right;  public Node(int item)  {  key = item;  left = right = null;  } } 

#include  // Node structure to define the structure of the node typedef struct Node {  int data;  struct Node *left, *right; } Node; // Function to create a new node Node* newNode(int val) {  Node* temp = (Node*)malloc(sizeof(Node));  temp->데이터 = 발;  온도->왼쪽 = 온도->오른쪽 = NULL;  복귀온도; } // 노드를 삽입하는 함수 Node* insert(Node* root, int data) { // 트리가 비어 있으면 새 노드가 루트가 됩니다. if (root == NULL) { root = newNode(data);  루트를 반환;  } // 트리를 순회하고 노드를 삽입할 위치를 찾기 위한 큐 Node* queue[100];  int 앞 = 0, 뒤 = 0;  대기열[rear++] = 루트;  while (앞 != 뒤) { Node* temp = queue[front++];  // 부모 노드의 왼쪽 자식으로 노드를 삽입합니다. if (temp->left == NULL) { temp->left = newNode(data);  부서지다;  } // 왼쪽 자식이 null이 아니면 큐에 푸시합니다. else queue[rear++] = temp->left;  // 부모 노드의 오른쪽 자식으로 노드를 삽입합니다. if (temp->right == NULL) { temp->right = newNode(data);  부서지다;  } // 오른쪽 자식이 null이 아니면 큐에 푸시합니다. else queue[rear++] = temp->right;  } 루트를 반환합니다; } /* 이진 트리에서 주어진 가장 깊은 노드(d_node)를 삭제하는 함수 */ void deletDeepest(Node* root, Node* d_node) { Node* queue[100];  int 앞 = 0, 뒤 = 0;  대기열[rear++] = 루트;  // 마지막 노드까지 레벨 순서 순회를 수행합니다. Node* temp;  while (앞 != 뒤) { temp = 대기열[앞++];  if (temp == d_node) { temp = NULL;  무료(d_node);  반품;  } if (temp->right) { if (temp->right == d_node) { temp->right = NULL;  무료(d_node);  반품;  } else queue[rear++] = 임시->오른쪽;  } if (temp->left) { if (temp->left == d_node) { temp->left = NULL;  무료(d_node);  반품;  } else queue[rear++] = 임시->왼쪽;  } } } /* 이진 트리에서 요소를 삭제하는 함수 */ Node* 삭제(Node* root, int key) { if (!root) return NULL;  if (루트->왼쪽 == NULL && 루트->오른쪽 == NULL) { if (루트->데이터 == 키) return NULL;  그렇지 않으면 루트를 반환합니다.  } 노드* 대기열[100];  int 앞 = 0, 뒤 = 0;  대기열[rear++] = 루트;  노드* 온도;  노드* key_node = NULL;  // 가장 깊은 노드(temp)와 삭제할 노드(key_node)를 찾기 위해 레벨 순서 순회를 수행합니다. while (front != Rear) { temp = queue[front++];  if (temp->data == key) key_node = 임시;  if (temp->left) queue[rear++] = temp->left;  if (temp->right) queue[rear++] = temp->right;  } if (key_node != NULL) { int x = 임시->데이터;  key_node->data = x;  deleteDeepest(루트, 임시);  } 루트를 반환합니다; } // 중위 트리 순회(왼쪽 - 루트 - 오른쪽) void inorderTraversal(Node* root) { if (!root) return;  inorderTraversal(루트->왼쪽);  printf('%d ', 루트->데이터);  inorderTraversal(루트->오른쪽); } // 선주문 트리 순회(루트 - 왼쪽 - 오른쪽) void preorderTraversal(Node* root) { if (!root) return;  printf('%d ', 루트->데이터);  preorderTraversal(루트->왼쪽);  preorderTraversal(루트->오른쪽); } // 후위 트리 탐색 (왼쪽 - 오른쪽 - 루트) void postorderTraversal(Node* root) { if (root == NULL) return;  postorderTraversal(루트->왼쪽);  postorderTraversal(루트->오른쪽);  printf('%d ', 루트->데이터); } // 레벨 순서 트리 탐색을 위한 함수 void levelorderTraversal(Node* root) { if (root == NULL) return;  // 레벨 순서 탐색을 위한 큐 Node* queue[100];  int 앞 = 0, 뒤 = 0;  대기열[rear++] = 루트;  while (앞 != 뒤) { Node* temp = queue[front++];  printf('%d ', 임시->데이터);  // (temp->left) queue[rear++] = temp->left인 경우 대기열에 왼쪽 자식을 푸시합니다.  // (temp->right) queue[rear++] = temp->right인 경우 대기열의 오른쪽 자식을 푸시합니다.  } } /* 위의 알고리즘을 확인하는 드라이버 함수입니다. */ int main() { 노드* 루트 = NULL;  // 노드 삽입 root = insert(root, 10);  루트 = 삽입(루트, 20);  루트 = 삽입(루트, 30);  루트 = 삽입(루트, 40);  printf('선주문 순회: ');  preorderTraversal(root);  printf('
중순 순회: ');  inorderTraversal(루트);  printf('
후순위 순회: ');  postorderTraversal(root);  printf('
레벨 순서 탐색: ');  levelorderTraversal(root);  // 데이터 = 20인 노드 삭제 root = delete(root, 20);  printf('
삭제 후 중순순회: ');  inorderTraversal(루트);  0을 반환합니다. } 

import java.util.LinkedList; import java.util.Queue; // Node class to define the structure of the node class Node {  int data;  Node left, right;  // Parameterized Constructor  Node(int val) {  data = val;  left = right = null;  } } public class BinaryTree {  // Function to insert nodes  public static Node insert(Node root, int data) {  // If tree is empty, new node becomes the root  if (root == null) {  root = new Node(data);  return root;  }  // Queue to traverse the tree and find the position to  // insert the node  Queue q = 새로운 LinkedList();  q.offer(루트);  while (!q.isEmpty()) { 노드 임시 = q.poll();  // 부모 노드의 왼쪽 자식으로 노드를 삽입합니다. if (temp.left == null) { temp.left = new Node(data);  부서지다;  } // 왼쪽 자식이 null이 아니면 // 대기열에 푸시합니다. else q.offer(temp.left);  // 부모 노드의 오른쪽 자식으로 노드를 삽입합니다. if (temp.right == null) { temp.right = new Node(data);  부서지다;  } // 오른쪽 자식이 null이 아니면 // 대기열에 푸시합니다. else q.offer(temp.right);  } 루트를 반환합니다;  } /* 이진 트리에서 주어진 가장 깊은 노드(d_node)를 삭제하는 함수 */ public static void deletDeepest(Node root, Node d_node) { Queue q = 새로운 LinkedList();  q.offer(루트);  // 마지막 노드까지 레벨 순서 순회를 수행합니다. Node temp;  while (!q.isEmpty()) { temp = q.poll();  if (temp == d_node) { temp = null;  d_node = null;  반품;  } if (temp.right != null) { if (temp.right == d_node) { temp.right = null;  d_node = null;  반품;  } else q.offer(temp.right);  } if (temp.left != null) { if (temp.left == d_node) { temp.left = null;  d_node = null;  반품;  } else q.offer(temp.left);  } } } /* 이진 트리에서 요소를 삭제하는 함수 */ public static Node delete(Node root, int key) { if (root == null) return null;  if (root.left == null && root.right == null) { if (root.data == key) return null;  그렇지 않으면 루트를 반환합니다.  }  대기줄 q = 새로운 LinkedList();  q.offer(루트);  노드 온도 = 새 노드(0);  노드 key_node = null;  // 가장 깊은 노드(temp)와 삭제할 노드(key_node)를 찾기 위해 레벨 순서 순회를 수행합니다. while (!q.isEmpty()) { temp = q.poll();  if (temp.data == key) key_node = 임시;  if (temp.left != null) q.offer(temp.left);  if (temp.right != null) q.offer(temp.right);  } if (key_node != null) { int x = temp.data;  key_node.data = x;  deleteDeepest(루트, 임시);  } 루트를 반환합니다;  } // 중위 트리 순회(왼쪽 - 루트 - 오른쪽) public static void inorderTraversal(Node root) { if (root == null) return;  inorderTraversal(root.left);  System.out.print(root.data + ' ');  inorderTraversal(root.right);  } // 선주문 트리 순회(루트 - 왼쪽 - 오른쪽) public static void preorderTraversal(Node root) { if (root == null) return;  System.out.print(root.data + ' ');  preorderTraversal(root.left);  preorderTraversal(root.right);  } // 후위 트리 순회(왼쪽 - 오른쪽 - 루트) public static void postorderTraversal(Node root) { if (root == null) return;  postorderTraversal(root.left);  postorderTraversal(root.right);  System.out.print(root.data + ' ');  } // 레벨 순서 트리 탐색을 위한 함수 public static void levelorderTraversal(Node root) { if (root == null) return;  // 레벨 순서 순회를 위한 큐 큐 q = 새로운 LinkedList();  q.offer(루트);  while (!q.isEmpty()) { 노드 임시 = q.poll();  System.out.print(temp.data + ' ');  // 대기열에 왼쪽 자식을 푸시합니다. if (temp.left != null) q.offer(temp.left);  // 대기열의 오른쪽 자식을 푸시합니다. if (temp.right != null) q.offer(temp.right);  } } /* 위의 알고리즘을 확인하는 드라이버 함수입니다. */ public static void main(String[] args) { 노드 루트 = null;  // 노드 삽입 root = insert(root, 10);  루트 = 삽입(루트, 20);  루트 = 삽입(루트, 30);  루트 = 삽입(루트, 40);  System.out.print('선주문 순회: ');  preorderTraversal(root);  System.out.print('
순서 순회: ');  inorderTraversal(루트);  System.out.print('
후순위 순회: ');  postorderTraversal(root);  System.out.print('
레벨 순서 탐색: ');  levelorderTraversal(root);  // 데이터 = 20인 노드 삭제 root = delete(root, 20);  System.out.print('
삭제 후 순회: ');  inorderTraversal(루트);  } } 

from collections import deque # Node class to define the structure of the node class Node: def __init__(self, val): self.data = val self.left = self.right = None # Function to insert nodes def insert(root, data): # If tree is empty, new node becomes the root if root is None: root = Node(data) return root # Queue to traverse the tree and find the position to insert the node q = deque() q.append(root) while q: temp = q.popleft() # Insert node as the left child of the parent node if temp.left is None: temp.left = Node(data) break # If the left child is not null push it to the queue else: q.append(temp.left) # Insert node as the right child of parent node if temp.right is None: temp.right = Node(data) break # If the right child is not null push it to the queue else: q.append(temp.right) return root # Function to delete the given deepest node (d_node) in binary tree def deletDeepest(root, d_node): q = deque() q.append(root) # Do level order traversal until last node while q: temp = q.popleft() if temp == d_node: temp = None del d_node return if temp.right: if temp.right == d_node: temp.right = None del d_node return else: q.append(temp.right) if temp.left: if temp.left == d_node: temp.left = None del d_node return else: q.append(temp.left) # Function to delete element in binary tree def deletion(root, key): if not root: return None if root.left is None and root.right is None: if root.data == key: return None else: return root q = deque() q.append(root) temp = None key_node = None # Do level order traversal to find deepest node (temp) and node to be deleted (key_node) while q: temp = q.popleft() if temp.data == key: key_node = temp if temp.left: q.append(temp.left) if temp.right: q.append(temp.right) if key_node is not None: x = temp.data key_node.data = x deletDeepest(root, temp) return root # Inorder tree traversal (Left - Root - Right) def inorderTraversal(root): if not root: return inorderTraversal(root.left) print(root.data, end=' ') inorderTraversal(root.right) # Preorder tree traversal (Root - Left - Right) def preorderTraversal(root): if not root: return print(root.data, end=' ') preorderTraversal(root.left) preorderTraversal(root.right) # Postorder tree traversal (Left - Right - Root) def postorderTraversal(root): if root is None: return postorderTraversal(root.left) postorderTraversal(root.right) print(root.data, end=' ') # Function for Level order tree traversal def levelorderTraversal(root): if root is None: return # Queue for level order traversal q = deque() q.append(root) while q: temp = q.popleft() print(temp.data, end=' ') # Push left child in the queue if temp.left: q.append(temp.left) # Push right child in the queue if temp.right: q.append(temp.right) # Driver function to check the above algorithm if __name__ == '__main__': root = None # Insertion of nodes root = insert(root, 10) root = insert(root, 20) root = insert(root, 30) root = insert(root, 40) print('Preorder traversal:', end=' ') preorderTraversal(root) print('
Inorder traversal:', end=' ') inorderTraversal(root) print('
Postorder traversal:', end=' ') postorderTraversal(root) print('
Level order traversal:', end=' ') levelorderTraversal(root) # Delete the node with data = 20 root = deletion(root, 20) print('
Inorder traversal after deletion:', end=' ') inorderTraversal(root) 

using System; using System.Collections.Generic; // Node class to define the structure of the node public class Node {  public int data;  public Node left, right;  // Parameterized Constructor  public Node(int val)  {  data = val;  left = right = null;  } } public class Program {  // Function to insert nodes  public static Node Insert(Node root, int data)  {  // If tree is empty, new node becomes the root  if (root == null)  {  root = new Node(data);  return root;  }  // Queue to traverse the tree and find the position to insert the node  Queue q = 새 대기열 ();  q.인큐(루트);  while (q.Count != 0) { 노드 임시 = q.Dequeue();  // 부모 노드의 왼쪽 자식으로 노드를 삽입합니다. if (temp.left == null) { temp.left = new Node(data);  부서지다;  } // 왼쪽 자식이 null이 아니면 큐에 푸시합니다. else q.Enqueue(temp.left);  // 부모 노드의 오른쪽 자식으로 노드를 삽입합니다. if (temp.right == null) { temp.right = new Node(data);  부서지다;  } // 오른쪽 자식이 null이 아니면 큐에 푸시합니다. else q.Enqueue(temp.right);  } 루트를 반환합니다;  } /* 이진 트리에서 주어진 가장 깊은 노드(d_node)를 삭제하는 함수 */ public static void DeleteDeepest(Node root, Node d_node) { Queue q = 새 대기열 ();  q.인큐(루트);  // 마지막 노드까지 레벨 순서 순회를 수행합니다. Node temp;  while (q.Count != 0) { temp = q.Dequeue();  if (temp == d_node) { temp = null;  d_node = null;  반품;  } if (temp.right != null) { if (temp.right == d_node) { temp.right = null;  d_node = null;  반품;  } else q.Enqueue(temp.right);  } if (temp.left != null) { if (temp.left == d_node) { temp.left = null;  d_node = null;  반품;  } else q.Enqueue(temp.left);  } } } /* 이진 트리에서 요소를 삭제하는 함수 */ public static Node Deletion(Node root, int key) { if (root == null) return null;  if (root.left == null && root.right == null) { if (root.data == key) return null;  그렇지 않으면 루트를 반환합니다.  }  대기줄 q = 새 대기열 ();  q.인큐(루트);  노드 온도 = 새 노드(0);  노드 key_node = null;  // 가장 깊은 노드(temp)와 삭제할 노드(key_node)를 찾기 위해 레벨 순서 순회를 수행합니다. while (q.Count != 0) { temp = q.Dequeue();  if (temp.data == key) key_node = 임시;  if (temp.left != null) q.Enqueue(temp.left);  if (temp.right != null) q.Enqueue(temp.right);  } if (key_node != null) { int x = temp.data;  key_node.data = x;  DeleteDeepest(루트, 임시);  } 루트를 반환합니다;  } // 중위 트리 순회(왼쪽 - 루트 - 오른쪽) public static void InorderTraversal(Node root) { if (root == null) return;  InorderTraversal(root.left);  Console.Write(root.data + ' ');  InorderTraversal(root.right);  } // 선주문 트리 순회(루트 - 왼쪽 - 오른쪽) public static void PreorderTraversal(노드 루트) { if (root == null) return;  Console.Write(root.data + ' ');  PreorderTraversal(root.left);  PreorderTraversal(root.right);  } // 후위 트리 순회(왼쪽 - 오른쪽 - 루트) public static void PostorderTraversal(Node root) { if (root == null) return;  PostorderTraversal(root.left);  PostorderTraversal(root.right);  Console.Write(root.data + ' ');  } // 레벨 순서 트리 탐색을 위한 함수 public static void LevelorderTraversal(Node root) { if (root == null) return;  // 레벨 순서 순회를 위한 큐 큐 q = 새 대기열 ();  q.인큐(루트);  while (q.Count != 0) { 노드 임시 = q.Dequeue();  Console.Write(temp.data + ' ');  // 대기열에 왼쪽 자식을 푸시합니다. if (temp.left != null) q.Enqueue(temp.left);  // 대기열의 오른쪽 자식을 푸시합니다. if (temp.right != null) q.Enqueue(temp.right);  } } /* 위의 알고리즘을 확인하는 드라이버 함수입니다. */ public static void Main(string[] args) { 노드 루트 = null;  // 노드 삽입 root = Insert(root, 10);  루트 = 삽입(루트, 20);  루트 = 삽입(루트, 30);  루트 = 삽입(루트, 40);  Console.Write('선주문 순회: ');  PreorderTraversal(루트);  Console.Write('
중순 순회: ');  InorderTraversal(루트);  Console.Write('
후순 순회: ');  PostorderTraversal(루트);  Console.Write('
레벨 순서 탐색: ');  LevelorderTraversal(루트);  // 데이터 = 20인 노드 삭제 root = Deletion(root, 20);  Console.Write('
삭제 후 순회: ');  InorderTraversal(루트);  } } 

// Node class to define the structure of the node class Node {  constructor(val) {  this.data = val;  this.left = null;  this.right = null;  } } // Function to insert nodes function insert(root, data) {  // If tree is empty, new node becomes the root  if (root === null) {  root = new Node(data);  return root;  }  // queue to traverse the tree and find the position to  // insert the node  const q = [];  q.push(root);  while (q.length !== 0) {  const temp = q.shift();  // Insert node as the left child of the parent node  if (temp.left === null) {  temp.left = new Node(data);  break;  }  // If the left child is not null push it to the  // queue  else  q.push(temp.left);  // Insert node as the right child of parent node  if (temp.right === null) {  temp.right = new Node(data);  break;  }  // If the right child is not null push it to the  // queue  else  q.push(temp.right);  }  return root; } /* function to delete the given deepest node (d_node) in binary tree */ function deletDeepest(root, d_node) {  const q = [];  q.push(root);  // Do level order traversal until last node  let temp;  while (q.length !== 0) {  temp = q.shift();  if (temp === d_node) {  temp = null;  delete d_node;  return;  }  if (temp.right) {  if (temp.right === d_node) {  temp.right = null;  delete d_node;  return;  }  else  q.push(temp.right);  }  if (temp.left) {  if (temp.left === d_node) {  temp.left = null;  delete d_node;  return;  }  else  q.push(temp.left);  }  } } /* function to delete element in binary tree */ function deletion(root, key) {  if (!root)  return null;  if (root.left === null && root.right === null) {  if (root.data === key)  return null;  else  return root;  }  const q = [];  q.push(root);  let temp;  let key_node = null;  // Do level order traversal to find deepest  // node(temp) and node to be deleted (key_node)  while (q.length !== 0) {  temp = q.shift();  if (temp.data === key)  key_node = temp;  if (temp.left)  q.push(temp.left);  if (temp.right)  q.push(temp.right);  }  if (key_node !== null) {  const x = temp.data;  key_node.data = x;  deletDeepest(root, temp);  }  return root; } // Inorder tree traversal (Left - Root - Right) function inorderTraversal(root) {  if (!root)  return;  inorderTraversal(root.left);  console.log(root.data + ' ');  inorderTraversal(root.right); } // Preorder tree traversal (Root - Left - Right) function preorderTraversal(root) {  if (!root)  return;  console.log(root.data + ' ');  preorderTraversal(root.left);  preorderTraversal(root.right); } // Postorder tree traversal (Left - Right - Root) function postorderTraversal(root) {  if (root === null)  return;  postorderTraversal(root.left);  postorderTraversal(root.right);  console.log(root.data + ' '); } // Function for Level order tree traversal function levelorderTraversal(root) {  if (root === null)  return;  // Queue for level order traversal  const q = [];  q.push(root);  while (q.length !== 0) {  const temp = q.shift();  console.log(temp.data + ' ');  // Push left child in the queue  if (temp.left)  q.push(temp.left);  // Push right child in the queue  if (temp.right)  q.push(temp.right);  } } /* Driver function to check the above algorithm. */ let root = null; // Insertion of nodes root = insert(root, 10); root = insert(root, 20); root = insert(root, 30); root = insert(root, 40); console.log('Preorder traversal: '); preorderTraversal(root); console.log('
Inorder traversal: '); inorderTraversal(root); console.log('
Postorder traversal: '); postorderTraversal(root); console.log('
Level order traversal: '); levelorderTraversal(root); // Delete the node with data = 20 root = deletion(root, 20); console.log('
Inorder traversal after deletion: '); inorderTraversal(root); 

#include  using namespace std; // Node class to define the structure of the node class Node { public:  int data;  Node *left, *right;  // Parameterized Constructor  Node(int val)  {  data = val;  left = right = NULL;  } }; // Function to insert nodes Node* insert(Node* root, int data) {  // If tree is empty, new node becomes the root  if (root == NULL) {  root = new Node(data);  return root;  }  // queue to traverse the tree and find the position to  // insert the node  queue 큐;  q.push(루트);  while (!q.empty()) { Node* temp = q.front();  q.pop();  // 부모 노드의 왼쪽 자식으로 노드를 삽입합니다. if (temp->left == NULL) { temp->left = new Node(data);  부서지다;  } // 왼쪽 자식이 null이 아니면 // 대기열에 푸시합니다. else q.push(temp->left);  // 부모 노드의 오른쪽 자식으로 노드를 삽입합니다. if (temp->right == NULL) { temp->right = new Node(data);  부서지다;  } // 오른쪽 자식이 null이 아니면 // 대기열에 푸시합니다. else q.push(temp->right);  } 루트를 반환합니다; } /* 이진 트리에서 주어진 가장 깊은 노드(d_node)를 삭제하는 함수 */ void deletDeepest(Node* root, Node* d_node) { queue 큐;  q.push(루트);  // 마지막 노드까지 레벨 순서 순회를 수행합니다. Node* temp;  while (!q.empty()) { temp = q.front();  q.pop();  if (temp == d_node) { temp = NULL;  삭제(d_node);  반품;  } if (temp->right) { if (temp->right == d_node) { temp->right = NULL;  삭제(d_node);  반품;  } else q.push(temp->right);  } if (temp->left) { if (temp->left == d_node) { temp->left = NULL;  삭제(d_node);  반품;  } else q.push(임시->왼쪽);  } } } /* 이진 트리에서 요소를 삭제하는 함수 */ Node* 삭제(Node* root, int key) { if (!root) return NULL;  if (루트->왼쪽 == NULL && 루트->오른쪽 == NULL) { if (루트->데이터 == 키) return NULL;  그렇지 않으면 루트를 반환합니다.  }  대기줄 큐;  q.push(루트);  노드* 온도;  노드* key_node = NULL;  // 가장 깊은 노드(temp)와 삭제할 노드(key_node)를 찾기 위해 레벨 순서 순회를 수행합니다. while (!q.empty()) { temp = q.front();  q.pop();  if (temp->data == key) key_node = 임시;  if (온도->왼쪽) q.push(온도->왼쪽);  if (온도->오른쪽) q.push(온도->오른쪽);  } if (key_node != NULL) { int x = 임시->데이터;  key_node->data = x;  deleteDeepest(루트, 임시);  } 루트를 반환합니다; } // 중위 트리 순회(왼쪽 - 루트 - 오른쪽) void inorderTraversal(Node* root) { if (!root) return;  inorderTraversal(루트->왼쪽);  시합 < < root->데이터 < < ' ';  inorderTraversal(root->오른쪽); } // 선주문 트리 순회(루트 - 왼쪽 - 오른쪽) void preorderTraversal(Node* root) { if (!root) return;  시합 < < root->데이터 < < ' ';  preorderTraversal(root->왼쪽);  preorderTraversal(루트->오른쪽); } // 후위 트리 탐색 (왼쪽 - 오른쪽 - 루트) void postorderTraversal(Node* root) { if (root == NULL) return;  postorderTraversal(루트->왼쪽);  postorderTraversal(루트->오른쪽);  시합 < < root->데이터 < < ' '; } // Function for Level order tree traversal void levelorderTraversal(Node* root) {  if (root == NULL)  return;  // Queue for level order traversal  queue 큐;  q.push(루트);  while (!q.empty()) { Node* temp = q.front();  q.pop();  시합 < < temp->데이터 < < ' ';  // Push left child in the queue  if (temp->왼쪽) q.push(임시->왼쪽);  // 큐의 오른쪽 자식을 푸시합니다. if (temp->right) q.push(temp->right);  } } /* 위의 알고리즘을 확인하는 드라이버 함수입니다. */ int main() { 노드* 루트 = NULL;  // 노드 삽입 root = insert(root, 10);  루트 = 삽입(루트, 20);  루트 = 삽입(루트, 30);  루트 = 삽입(루트, 40);  시합 < < 'Preorder traversal: ';  preorderTraversal(root);  cout  < < '
Inorder traversal: ';  inorderTraversal(root);  cout  < < '
Postorder traversal: ';  postorderTraversal(root);  cout  < < '
Level order traversal: ';  levelorderTraversal(root);  // Delete the node with data = 20  root = deletion(root, 20);  cout  < < '
Inorder traversal after deletion: ';  inorderTraversal(root); }