Árbol binario y recorridos

Genera un árbol binario de búsqueda y recórrelo paso a paso en preorden, inorden o postorden con una función recursiva de C++.

Todo se simula en este navegador; no se envía nada a ningún servidor.

Visita el nodo, luego el subárbol izquierdo y luego el derecho.

Se llama a la función con el nodo 60

Se llama a la función con el nodo 60

Árbol binario

60458568215532

Salida

Aún no se ha visitado ningún nodo

  • Sin visitar
  • En ejecución
  • En la pila
  • Visitado

Paso 1 / 44

Código

#include <iostream>
using namespace std;
class Node { // Un nodo guarda su valor y los punteros a sus dos hijos
private: // Atributos privados: solo se tocan con los métodos
int value;
Node* left;
Node* right;
public:
Node(int v) : value(v), left(nullptr), right(nullptr) {}
int getValue() const { return value; }
Node* getLeft() const { return left; }
Node* getRight() const { return right; }
void setLeft(Node* n) { left = n; }
void setRight(Node* n) { right = n; }
};
void preorder(Node* node) { // Recorre el subárbol que cuelga de node
if (node == nullptr) return; // Caso base: un subárbol vacío no tiene nada que visitar
cout << node->getValue() << " "; // Visita el nodo: procesa su valor
preorder(node->getLeft()); // Recorre el subárbol izquierdo
preorder(node->getRight()); // Recorre el subárbol derecho
} // Vuelve al llamador
Node* insert(Node* root, int v) { // Inserta v en el árbol de búsqueda y devuelve la raíz
if (root == nullptr) return new Node(v); // Hueco vacío: aquí va el nodo nuevo
if (v < root->getValue()) // Los menores van a la izquierda y los mayores a la derecha
root->setLeft(insert(root->getLeft(), v));
else
root->setRight(insert(root->getRight(), v));
return root;
}
Node* buildTree() { // Construye el árbol insertando los valores uno a uno
int values[] = {60, 45, 85, 68, 21, 55, 32}; // Los valores del árbol mostrado, en el orden de inserción
Node* root = nullptr;
for (int v : values) root = insert(root, v);
return root;
}
int main() {
Node* root = buildTree(); // El árbol de la animación, ya construido
preorder(root); // Primera llamada, desde main
cout << endl; // Fin del recorrido
return 0;
}

Esta herramienta genera un árbol binario de búsqueda (BST) con valores aleatorios y lo recorre paso a paso con una función recursiva de C++. Eliges preorden, inorden o postorden y ves sobre el mismo árbol cuándo se visita cada nodo: antes de sus hijos, entre ellos o después. Los nodos se colorean según su estado (sin visitar, en ejecución, en la pila o visitado), una tira de salida muestra los valores en el orden en que se visitan y el código resalta la línea que se ejecuta. También se ven las llamadas con nullptr, el caso base que detiene la recursión. Puedes cambiar el tamaño de 3 a 15 nodos y generar otro árbol. Todo se simula en tu navegador.

Cómo se usa

  1. Elige el recorrido: Preorden, Inorden o Postorden.
  2. Ajusta el tamaño del árbol con el deslizante o pulsa Generar árbol nuevo; la animación vuelve al primer paso.
  3. Pulsa Reproducir o avanza con los botones de paso anterior y siguiente, y cambia la velocidad si lo necesitas.
  4. Observa los nodos coloreados, la tira de salida con los valores visitados y la línea resaltada del código C++.

Preguntas frecuentes

¿Qué es un árbol binario y qué es un árbol binario de búsqueda?
Un árbol binario es una estructura en la que cada nodo tiene como máximo dos hijos, izquierdo y derecho. En un árbol binario de búsqueda (BST) además se cumple que los valores del subárbol izquierdo son menores que el del nodo y los del derecho, mayores.
¿Qué diferencia hay entre preorden, inorden y postorden?
Cambia cuándo se visita el nodo respecto a sus hijos. En preorden se visita primero el nodo y después los subárboles izquierdo y derecho; en inorden, el izquierdo, el nodo y el derecho; en postorden, el izquierdo, el derecho y al final el nodo. El preorden sirve para copiar un árbol, el inorden para leer un BST en orden y el postorden para liberar o evaluar un árbol, porque los hijos se procesan antes que el padre.
¿Por qué el inorden de un BST sale ordenado?
Porque en un BST todo lo que hay a la izquierda de un nodo es menor y todo lo que hay a la derecha, mayor. Al visitar el subárbol izquierdo, luego el nodo y luego el derecho, los valores se producen de menor a mayor.
¿Cómo se implementa un recorrido recursivo en C++?
Con una función que recibe un puntero a un nodo. Si el puntero es nullptr, vuelve sin hacer nada: es el caso base. Si no, visita el nodo y se llama a sí misma con el hijo izquierdo y con el derecho, en el orden que marque el recorrido.

Herramientas relacionadas