Nodos y estructura de árboles
Modele un nodo con punteros
Nodos y estructura de árboles es una lección gratuita de C Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.
¿Qué es un árbol binario?
Un árbol binario es una estructura jerárquica en la que cada nodo contiene un valor y enlaces a un máximo de dos hijos: un hijo izquierdo y uno derecho.
El nodo situado más arriba es la raíz. Los nodos sin hijos son hojas. Esta forma hace que los árboles binarios sean excelentes para búsquedas rápidas, ordenación y procesamiento recursivo.
La struct del nodo
En C modelamos un nodo con una struct que almacena los datos y dos punteros autorreferentes.
Cada puntero apunta a otro Node o a NULL cuando no hay ningún hijo en ese lado.
struct Node {
int value;
struct Node *left;
struct Node *right;
};Por qué usar punteros autorreferentes
Un nodo no puede contener otro nodo completo por valor, porque eso requeriría un almacenamiento infinito. En su lugar, contiene punteros a sus hijos.
Los punteros tienen un tamaño fijo, por lo que la struct mantiene un tamaño conocido y, al mismo tiempo, puede enlazar con otros nodos del heap.
struct Node {
int value;
struct Node *left; /* 8 bytes on 64-bit */
struct Node *right; /* 8 bytes on 64-bit */
};Un typedef por comodidad
Escribir struct Node en todas partes resulta tedioso. Un typedef permite escribir simplemente Node.
La etiqueta sigue siendo necesaria dentro de la struct porque en ese punto el tipo todavía no está completamente definido.
typedef struct Node {
int value;
struct Node *left;
struct Node *right;
} Node;Asignar un Node
Los nodos viven en el heap y se crean con malloc. Establecemos el valor e inicializamos ambos punteros a los hijos a NULL.
Compruebe siempre que malloc no haya devuelto NULL antes de usar la memoria.
Node *create_node(int value) {
Node *n = malloc(sizeof(Node));
if (n == NULL) return NULL;
n->value = value;
n->left = NULL;
n->right = NULL;
return n;
}Construir manualmente un árbol pequeño
Para entender los enlaces, conectemos manualmente tres nodos: una raíz con dos hijos.
Este programa construye el árbol e imprime los valores; después normalmente lo liberaríamos (lo veremos más adelante).
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int value;
struct Node *left;
struct Node *right;
} Node;
Node *create_node(int v) {
Node *n = malloc(sizeof(Node));
n->value = v; n->left = NULL; n->right = NULL;
return n;
}
int main(void) {
Node *root = create_node(10);
root->left = create_node(5);
root->right = create_node(15);
printf("%d %d %d\n", root->left->value, root->value, root->right->value);
return 0;
}Llegar a los nietos
Para recorrer el árbol, encadene el operador flecha. root->left->right baja hasta el hijo izquierdo y después hasta su hijo derecho.
Antes de seguir un puntero, asegúrese de que no sea NULL o el programa se bloqueará.
/* root
* \
* right (15)
* \
* right->right (20)
*/
if (root->right != NULL && root->right->right != NULL)
printf("%d\n", root->right->right->value);Contar nodos recursivamente
La recursividad encaja de forma natural con los árboles. Para contar los nodos, un subárbol vacío tiene cero nodos; en caso contrario, contamos este nodo más ambos subárboles.
La comprobación de NULL es el caso base que detiene la recursividad.
int count_nodes(Node *root) {
if (root == NULL) return 0;
return 1 + count_nodes(root->left)
+ count_nodes(root->right);
}Medir la altura
La altura de un árbol es el camino más largo desde la raíz hasta una hoja, medido en aristas.
Tomamos la mayor de las alturas de los dos subárboles y sumamos uno. A un árbol vacío se le asigna una altura de -1, de modo que un nodo único tenga altura 0.
int height(Node *root) {
if (root == NULL) return -1;
int l = height(root->left);
int r = height(root->right);
return 1 + (l > r ? l : r);
}Identificar las hojas
Una hoja es un nodo sin hijos: tanto left como right son NULL.
Este pequeño helper resulta útil en muchas rutinas de recorrido y conteo.
int is_leaf(Node *n) {
return n != NULL && n->left == NULL && n->right == NULL;
}Poner la estructura en práctica
Aquí se construye un árbol pequeño y se muestran su cantidad de nodos y su altura mediante los helpers recursivos.
Observe que los helpers nunca suponen una forma fija; funcionan con cualquier árbol porque la recursividad sigue los punteros reales.
#include <stdio.h>
#include <stdlib.h>
typedef struct Node { int value; struct Node *left, *right; } Node;
Node *nn(int v){ Node *n=malloc(sizeof(Node)); n->value=v; n->left=n->right=NULL; return n; }
int count(Node *r){ return r? 1+count(r->left)+count(r->right):0; }
int height(Node *r){ if(!r) return -1; int l=height(r->left),x=height(r->right); return 1+(l>x?l:x); }
int main(void){
Node *root = nn(10);
root->left = nn(5); root->right = nn(15);
root->left->left = nn(2);
printf("nodes=%d height=%d\n", count(root), height(root));
return 0;
}Comprobación rápida
Compruebe su comprensión de la estructura de los nodos.
Resumen
Un nodo de árbol binario contiene un valor y dos punteros autorreferentes (left, right), establecidos a NULL cuando no están presentes.
Asignamos los nodos con malloc, los enlazamos manualmente y los procesamos de forma recursiva. La comprobación de NULL siempre es el caso base para contar, calcular la altura y comprobar las hojas.
Preguntas frecuentes
¿La lección «Nodos y estructura de árboles» es gratis?
Sí — el texto completo de «Nodos y estructura de árboles» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Nodos y estructura de árboles»?
Modele un nodo con punteros Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C Academy?
No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Nodos y estructura de árboles»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C Academy?
Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Nodos y estructura de árboles
- Insertar en un BST
- Recorridos
- Buscar y liberar