Cuando trabajamos con árboles binarios de búsqueda en C, una de las tareas fundamentales es poder imprimir su contenido de manera que refleje su estructura y facilite su comprensión. Para ello, podemos aprovechar los recorridos clásicos: preorden, inorden y postorden, que nos permiten procesar los nodos del árbol siguiendo diferentes órdenes.
Empezamos por el recorrido en preorden. La idea es sencilla: primero procesamos la raíz, luego el subárbol izquierdo y finalmente el subárbol derecho. Para implementarlo, definimos una función recursiva que primero verifica si el árbol está vacío, que será nuestro caso base. Si no lo está, imprimimos el valor del nodo actual, y luego llamamos recursivamente a la función para el hijo izquierdo y después para el derecho. Para visualizar mejor la estructura, podemos imprimir un guion - cuando encontramos un árbol vacío y encerrar cada llamada en paréntesis, lo que nos ayuda a distinguir claramente cada subárbol.
void preorden(Arbol* arbol) {
if (arbol == NULL) {
printf("-");
return;
}
printf("(");
printf("%d", arbol->valor);
preorden(arbol->izquierdo);
preorden(arbol->derecho);
printf(")");
}
Al insertar elementos como 5, 10, 4, 9 y 15, y luego imprimir el árbol con esta función, veremos cómo se refleja la estructura: el 5 aparece primero porque es la raíz, el 10 se sitúa en el hijo derecho, el 4 en el izquierdo, y así sucesivamente. Aunque la impresión no incluye guiones o espacios adicionales para separar los valores, la representación con paréntesis y guiones nos permite entender la organización recursiva del árbol.
El recorrido en inorden cambia el orden en que procesamos los nodos: primero recorremos el subárbol izquierdo, luego imprimimos la raíz y finalmente recorremos el subárbol derecho. Esto nos da una impresión ordenada de los valores en un árbol binario de búsqueda, ya que los valores se muestran en orden ascendente. La función también es recursiva y sigue el mismo patrón de caso base para árboles vacíos.
void inorden(Arbol* arbol) {
if (arbol == NULL) {
printf("-");
return;
}
printf("(");
inorden(arbol->izquierdo);
printf("%d", arbol->valor);
inorden(arbol->derecho);
printf(")");
}
Al imprimir el árbol con esta función, los paréntesis nos ayudan a distinguir cada subárbol, y podemos ver claramente cómo los valores se ordenan de menor a mayor, reflejando la propiedad fundamental del árbol binario de búsqueda.
Finalmente, el recorrido en postorden procesa primero el subárbol izquierdo, luego el derecho y, por último, la raíz. La función sigue la misma estructura recursiva, con el caso base para árboles vacíos y la impresión de paréntesis para delimitar cada subárbol.
void postorden(Arbol* arbol) {
if (arbol == NULL) {
printf("-");
return;
}
printf("(");
postorden(arbol->izquierdo);
postorden(arbol->derecho);
printf("%d", arbol->valor);
printf(")");
}
Esta forma de imprimir nos muestra cómo se recorren primero los hijos antes de procesar el nodo padre, lo que puede ser útil para ciertas operaciones como la eliminación de nodos o la evaluación de expresiones en árboles.
En todos estos casos, la clave está en entender la recursividad y cómo el orden en que procesamos la raíz y los hijos cambia el resultado final. Además, la representación con paréntesis y guiones facilita la visualización de la estructura del árbol, permitiéndonos distinguir claramente cada subárbol y su posición relativa.
Aunque por ahora nos hemos centrado en imprimir el árbol, en futuras ocasiones podemos explorar cómo procesar los nodos para realizar otras operaciones, como reconstruir el árbol a partir de su representación o eliminar elementos, que también son aspectos fundamentales en el manejo de árboles binarios de búsqueda en C.