// 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->datos = valor;  temperatura->izquierda = temperatura->derecha = NULL;  temperatura de retorno; } // Función para insertar nodos Node* insert(Node* root, int data) { // Si el árbol está vacío, el nuevo nodo se convierte en la raíz if (root == NULL) { root = newNode(data);  devolver raíz;  } // Cola para recorrer el árbol y encontrar la posición para insertar el nodo Node* queue[100];  int frente = 0, trasero = 0;  cola[trasero++] = raíz;  while (frente! = trasero) { Nodo* temp = cola[frente++];  // Insertar nodo como hijo izquierdo del nodo padre if (temp->left == NULL) { temp->left = newNode(data);  romper;  } // Si el hijo izquierdo no es nulo, envíelo a la cola else queue[rear++] = temp->left;  // Insertar nodo como hijo derecho del nodo padre if (temp->right == NULL) { temp->right = newNode(data);  romper;  } // Si el hijo derecho no es nulo, envíelo a la cola else queue[rear++] = temp->right;  } devolver raíz; } /* Función para eliminar el nodo más profundo dado (d_node) en el árbol binario */ void deletDeepest(Node* root, Node* d_node) { Node* queue[100];  int frente = 0, trasero = 0;  cola[trasero++] = raíz;  // Realiza un recorrido de orden de nivel hasta el último nodo Node* temp;  while (frente! = trasero) { temp = cola[frente++];  if (temp == d_node) { temp = NULL;  libre(d_nodo);  devolver;  } if (temp->derecha) { if (temp->derecha == d_node) { temp->derecha = NULL;  libre(d_nodo);  devolver;  } else cola[trasero++] = temp->derecha;  } if (temp->izquierda) { if (temp->izquierda == d_node) { temp->izquierda = NULL;  libre(d_nodo);  devolver;  } else cola[trasero++] = temp->izquierda;  } } } /* Función para eliminar elemento en el árbol binario */ Eliminación de nodo*(Nodo* raíz, int clave) { if (!root) return NULL;  if (raíz->izquierda == NULL && raíz->derecha == NULL) { if (raíz->datos == clave) return NULL;  de lo contrario devolverá la raíz;  } Nodo* cola[100];  int frente = 0, trasero = 0;  cola[trasero++] = raíz;  Temperatura del nodo*;  Nodo* key_node = NULL;  // Realice un recorrido de orden de nivel para encontrar el nodo más profundo (temp) y el nodo que se eliminará (key_node) while (front != rear) { temp = queue[front++];  if (temp->datos == clave) key_node = temp;  if (temp->izquierda) cola[trasero++] = temp->izquierda;  if (temp->derecha) cola[trasero++] = temp->derecha;  } if (key_node! = NULL) { int x = temp->datos;  key_node->datos = x;  eliminarMás profundo(raíz, temporal);  } devolver raíz; } // Recorrido del árbol en orden (Izquierda - Raíz - Derecha) void inorderTraversal(Nodo* raíz) { if (!root) return;  inorderTraversal(raíz->izquierda);  printf('%d ', raíz->datos);  inorderTraversal(raíz->derecha); } // Recorrido del árbol de pedidos anticipados (Raíz - Izquierda - Derecha) void preorderTraversal(Nodo* raíz) { if (!root) return;  printf('%d ', raíz->datos);  preordenTraversal(raíz->izquierda);  preordenTraversal(raíz->derecha); } // recorrido del árbol de postorden (Izquierda - Derecha - Raíz) void postorderTraversal(Node* root) { if (root == NULL) return;  postorderTraversal(raíz->izquierda);  postorderTraversal(raíz->derecha);  printf('%d ', raíz->datos); } // Función para el recorrido del árbol de orden de niveles void levelorderTraversal(Node* root) { if (root == NULL) return;  // Cola para recorrido de orden de nivel Nodo* cola[100];  int frente = 0, trasero = 0;  cola[trasero++] = raíz;  while (frente! = trasero) { Nodo* temp = cola[frente++];  printf('%d ', temperatura->datos);  // Empujar al hijo izquierdo en la cola if (temp->left) queue[rear++] = temp->left;  // Empuja al hijo derecho en la cola if (temp->right) queue[rear++] = temp->right;  } } /* Función del controlador para comprobar el algoritmo anterior. */ int main() { Nodo* raíz = NULL;  // Inserción de nodos root = insert(root, 10);  raíz = insertar(raíz, 20);  raíz = insertar(raíz, 30);  raíz = insertar(raíz, 40);  printf('Recorrido de preorden: ');  preordenTraversal(raíz);  printf('
Recorrido en orden: ');  inorderTraversal(raíz);  printf('
Recorrido posterior al pedido: ');  postorderTraversal(raíz);  printf('
Recorrido de orden de niveles: ');  nivelordenTraversal(raíz);  // Eliminar el nodo con datos = 20 root = deletion(root, 20);  printf('
Recorrido en orden después de la eliminación: ');  inorderTraversal(raíz);  devolver 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 = nueva ListaEnlazada();  q.oferta(raíz);  while (!q.isEmpty()) { Temperatura del nodo = q.poll();  // Insertar nodo como hijo izquierdo del nodo padre if (temp.left == null) { temp.left = new Node(data);  romper;  } // Si el hijo izquierdo no es nulo, envíelo a la // cola else q.offer(temp.left);  // Insertar nodo como hijo derecho del nodo padre if (temp.right == null) { temp.right = new Node(data);  romper;  } // Si el hijo correcto no es nulo, envíelo a la // cola else q.offer(temp.right);  } devolver raíz;  } /* función para eliminar el nodo más profundo dado (d_node) en el árbol binario */ public static void deletDeepest(Node root, Node d_node) { Cola q = nueva ListaEnlazada();  q.oferta(raíz);  // Realiza un recorrido de orden de nivel hasta el último nodo Node temp;  mientras (!q.isEmpty()) { temp = q.poll();  if (temp == d_node) { temp = nulo;  d_nodo = nulo;  devolver;  } if (temp.right! = nulo) { if (temp.right == d_node) { temp.right = null;  d_nodo = nulo;  devolver;  } else q.oferta(temp.derecha);  } if (temp.izquierda! = nulo) { if (temp.izquierda == d_node) { temp.izquierda = nulo;  d_nodo = nulo;  devolver;  } else q.oferta(temp.izquierda);  } } } /* función para eliminar elemento en el árbol binario */ eliminación de nodo estático público (raíz del nodo, clave int) { if (root == null) return null;  if (root.left == null && root.right == null) { if (root.data == clave) return null;  de lo contrario devolverá la raíz;  }  Cola q = nueva ListaEnlazada();  q.oferta(raíz);  Temperatura del nodo = nuevo nodo (0);  Nodo key_node = nulo;  // Realice un recorrido de orden de nivel para encontrar el // nodo más profundo (temp) y el nodo que se eliminará (key_node) while (!q.isEmpty()) { temp = q.poll();  if (temp.data == clave) key_node = temp;  if (temp.izquierda! = nulo) q.oferta(temp.izquierda);  if (temp.derecho! = nulo) q.oferta(temp.derecho);  } if (key_node! = nulo) { int x = temp.data;  key_node.datos = x;  eliminarMás profundo(raíz, temporal);  } devolver raíz;  } // Recorrido del árbol en orden (Izquierda - Raíz - Derecha) public static void inorderTraversal(Node root) { if (root == null) return;  inorderTraversal(raíz.izquierda);  System.out.print(root.data + ' ');  inorderTraversal(raíz.derecha);  } // Recorrido del árbol de pedidos anticipados (Raíz - Izquierda - Derecha) public static void preorderTraversal(Node root) { if (root == null) return;  System.out.print(root.data + ' ');  preordenTraversal(root.left);  preordenTraversal(root.right);  } // recorrido del árbol de postorden (Izquierda - Derecha - Raíz) public static void postorderTraversal(Node root) { if (root == null) return;  postorderTraversal(root.left);  postorderTraversal(root.right);  System.out.print(root.data + ' ');  } // Función para el recorrido del árbol de orden de niveles public static void levelorderTraversal(Node root) { if (root == null) return;  // Cola para recorrido de orden de nivel Cola q = nueva ListaEnlazada();  q.oferta(raíz);  while (!q.isEmpty()) { Temperatura del nodo = q.poll();  System.out.print(temp.data + ' ');  // Empujar al hijo izquierdo en la cola if (temp.left != null) q.offer(temp.left);  // Empuja al hijo derecho en la cola if (temp.right != null) q.offer(temp.right);  } } /* Función del controlador para comprobar el algoritmo anterior. */ public static void main(String[] args) { Raíz del nodo = null;  // Inserción de nodos root = insert(root, 10);  raíz = insertar(raíz, 20);  raíz = insertar(raíz, 30);  raíz = insertar(raíz, 40);  System.out.print('Recorrido de reserva: ');  preordenTraversal(raíz);  System.out.print('
Recorrido en orden: ');  inorderTraversal(raíz);  System.out.print('
Recorrido posterior al pedido: ');  postorderTraversal(raíz);  System.out.print('
Recorrido de orden de niveles: ');  nivelordenTraversal(raíz);  // Eliminar el nodo con datos = 20 root = deletion(root, 20);  System.out.print('
Recorrido en orden después de la eliminación: ');  inorderTraversal(raíz);  } } 

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 = nueva cola ();  q.En cola (raíz);  while (q.Count != 0) { Temperatura del nodo = q.Dequeue();  // Insertar nodo como hijo izquierdo del nodo padre if (temp.left == null) { temp.left = new Node(data);  romper;  } // Si el hijo izquierdo no es nulo, envíelo a la cola else q.Enqueue(temp.left);  // Insertar nodo como hijo derecho del nodo padre if (temp.right == null) { temp.right = new Node(data);  romper;  } // Si el hijo derecho no es nulo, envíelo a la cola else q.Enqueue(temp.right);  } devolver raíz;  } /* función para eliminar el nodo más profundo dado (d_node) en el árbol binario */ public static void DeleteDeepest(Node root, Node d_node) { Cola q = nueva cola ();  q.En cola (raíz);  // Realiza un recorrido de orden de nivel hasta el último nodo Node temp;  while (q.Count != 0) { temp = q.Dequeue();  if (temp == d_node) { temp = nulo;  d_nodo = nulo;  devolver;  } if (temp.right! = nulo) { if (temp.right == d_node) { temp.right = null;  d_nodo = nulo;  devolver;  } else q.Enqueue(temp.right);  } if (temp.izquierda! = nulo) { if (temp.izquierda == d_node) { temp.izquierda = nulo;  d_nodo = nulo;  devolver;  } más q.Enqueue(temp.left);  } } } /* función para eliminar elemento en el árbol binario */ eliminación de nodo estático público (raíz del nodo, clave int) { if (root == null) return null;  if (root.left == null && root.right == null) { if (root.data == clave) return null;  de lo contrario devolverá la raíz;  }  Cola q = nueva cola ();  q.En cola (raíz);  Temperatura del nodo = nuevo nodo (0);  Nodo key_node = nulo;  // Realice un recorrido de orden de nivel para encontrar el nodo más profundo (temp) y el nodo que se eliminará (key_node) while (q.Count != 0) { temp = q.Dequeue();  if (temp.data == clave) key_node = temp;  if (temp.izquierda! = nulo) q.Enqueue(temp.izquierda);  if (temp.derecha! = nulo) q.Enqueue(temp.derecha);  } if (key_node! = nulo) { int x = temp.data;  key_node.datos = x;  Eliminar más profundo (raíz, temperatura);  } devolver raíz;  } // Recorrido del árbol en orden (Izquierda - Raíz - Derecha) public static void InorderTraversal(Node root) { if (root == null) return;  InorderTraversal(raíz.izquierda);  Consola.Write(root.data + ' ');  InorderTraversal(raíz.derecha);  } // Recorrido del árbol de pedidos anticipados (Raíz - Izquierda - Derecha) public static void PreorderTraversal(Node root) { if (root == null) return;  Consola.Write(root.data + ' ');  PreorderTraversal(root.left);  PreorderTraversal(root.right);  } // recorrido del árbol de postorden (Izquierda - Derecha - Raíz) public static void PostorderTraversal(Node root) { if (root == null) return;  PostorderTraversal(root.left);  PostorderTraversal(root.right);  Consola.Write(root.data + ' ');  } // Función para el recorrido del árbol de orden de niveles public static void LevelorderTraversal(Node root) { if (root == null) return;  // Cola para recorrido de orden de nivel Cola q = nueva cola ();  q.En cola (raíz);  while (q.Count != 0) { Temperatura del nodo = q.Dequeue();  Consola.Write(temp.data + ' ');  // Empujar al hijo izquierdo en la cola if (temp.left != null) q.Enqueue(temp.left);  // Empuja al hijo derecho en la cola if (temp.right != null) q.Enqueue(temp.right);  } } /* Función del controlador para comprobar el algoritmo anterior. */ public static void Main(string[] args) { Raíz del nodo = null;  // Inserción de nodos root = Insert(root, 10);  raíz = Insertar(raíz, 20);  raíz = Insertar(raíz, 30);  raíz = Insertar(raíz, 40);  Console.Write('Recorrido de reserva: ');  PreorderTraversal(raíz);  Console.Write('
Recorrido en orden: ');  InorderTraversal(raíz);  Console.Write('
Recorrido posterior al pedido: ');  PostorderTraversal(raíz);  Console.Write('
Recorrido de orden de niveles: ');  LevelorderTraversal(raíz);  // Eliminar el nodo con datos = 20 root = Deletion(root, 20);  Console.Write('
Recorrido en orden después de la eliminación: ');  InorderTraversal(raíz);  } } 

// 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;  q.push(raíz);  while (!q.empty()) { Nodo* temp = q.front();  q.pop();  // Insertar nodo como hijo izquierdo del nodo padre if (temp->left == NULL) { temp->left = new Node(data);  romper;  } // Si el hijo izquierdo no es nulo, envíelo a la // cola else q.push(temp->left);  // Insertar nodo como hijo derecho del nodo padre if (temp->right == NULL) { temp->right = new Node(data);  romper;  } // Si el hijo correcto no es nulo, envíelo a la // cola else q.push(temp->right);  } devolver raíz; } /* función para eliminar el nodo más profundo dado (d_node) en el árbol binario */ void deletDeepest(Node* root, Node* d_node) { cola q;  q.push(raíz);  // Realiza un recorrido de orden de nivel hasta el último nodo Node* temp;  mientras (!q.empty()) { temp = q.front();  q.pop();  if (temp == d_node) { temp = NULL;  eliminar (d_nodo);  devolver;  } if (temp->derecha) { if (temp->derecha == d_node) { temp->derecha = NULL;  eliminar (d_nodo);  devolver;  } else q.push(temp->right);  } if (temp->izquierda) { if (temp->izquierda == d_node) { temp->izquierda = NULL;  eliminar (d_nodo);  devolver;  } else q.push(temp->izquierda);  } } } /* función para eliminar elemento en el árbol binario */ Eliminación de nodo*(Nodo* raíz, clave int) { if (!root) return NULL;  if (raíz->izquierda == NULL && raíz->derecha == NULL) { if (raíz->datos == clave) return NULL;  de lo contrario devolverá la raíz;  }  cola q;  q.push(raíz);  Temperatura del nodo*;  Nodo* key_node = NULL;  // Realice un recorrido de orden de niveles para encontrar el // nodo (temp) más profundo y el nodo que se eliminará (key_node) while (!q.empty()) { temp = q.front();  q.pop();  if (temp->datos == clave) key_node = temp;  if (temp->izquierda) q.push(temp->izquierda);  if (temperatura->derecha) q.push(temperatura->derecha);  } if (key_node! = NULL) { int x = temp->datos;  key_node->datos = x;  eliminarMás profundo(raíz, temporal);  } devolver raíz; } // Recorrido del árbol en orden (Izquierda - Raíz - Derecha) void inorderTraversal(Nodo* raíz) { if (!root) return;  inorderTraversal(raíz->izquierda);  corte < < root->datos < < ' ';  inorderTraversal(root->bien); } // Recorrido del árbol de pedidos anticipados (Raíz - Izquierda - Derecha) void preorderTraversal(Nodo* raíz) { if (!root) return;  corte < < root->datos < < ' ';  preorderTraversal(root->izquierda);  preordenTraversal(raíz->derecha); } // recorrido del árbol de postorden (Izquierda - Derecha - Raíz) void postorderTraversal(Node* root) { if (root == NULL) return;  postorderTraversal(raíz->izquierda);  postorderTraversal(raíz->derecha);  corte < < root->datos < < ' '; } // Function for Level order tree traversal void levelorderTraversal(Node* root) {  if (root == NULL)  return;  // Queue for level order traversal  queue q;  q.push(raíz);  while (!q.empty()) { Nodo* temp = q.front();  q.pop();  corte < < temp->datos < < ' ';  // Push left child in the queue  if (temp->izquierda) q.push(temp->izquierda);  // Empuja al hijo derecho en la cola if (temp->right) q.push(temp->right);  } } /* Función del controlador para comprobar el algoritmo anterior. */ int main() { Nodo* raíz = NULL;  // Inserción de nodos root = insert(root, 10);  raíz = insertar(raíz, 20);  raíz = insertar(raíz, 30);  raíz = insertar(raíz, 40);  corte < < '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); }