Laboratorio de memoria y punteros en C

Sublista

Acerca de esta estructura

Padres con sublistas de hijos.

Abrir guía de Sublista

1 Preparar

2 Visualizar y ejecutar

3 Relacionar con código

Código C: Insertar padre

/**
 * @brief Inserta un nuevo nodo padre al final de la lista principal.
 * @param[in,out] lista       Doble puntero a la lista principal.
 * @param[in]     valor_padre Valor del nuevo padre.
 * @return Puntero al nuevo nodo insertado, o NULL si falla.
 * @note Admite valores repetidos como reservas distintas. Con lista NULL o malloc fallido retorna NULL sin modificar la cadena.
 */
Nodo *sublista_insertar_padre_final(Nodo **lista, int valor_padre) {
    Nodo *nuevo;
    Nodo *actual;

    if (lista == NULL) {
        return NULL;
    }

    nuevo = crear_padre(valor_padre);
    if (nuevo == NULL) {
        return NULL;
    }

    if (*lista == NULL) {
        *lista = nuevo;
        return nuevo;
    }

    actual = *lista;
    while (actual->sgte != NULL) {
        actual = actual->sgte;
    }
    actual->sgte = nuevo;
    return nuevo;
}

/**
 * @brief Crea un nuevo nodo padre.
 * @param[in] valor Valor entero a almacenar.
 * @return Puntero al nuevo nodo, o NULL si falla la memoria.
 * @note Inicializa nro con valor, sgte y sub en NULL; si malloc falla no hay reserva que liberar.
 */
static Nodo *crear_padre(int valor) {
    Nodo *nuevo = (Nodo *)malloc(sizeof(Nodo));
    if (nuevo == NULL) {
        return NULL;
    }
    nuevo->nro = valor;
    nuevo->sgte = NULL;
    nuevo->sub = NULL;
    return nuevo;
}

3 Controlar la ejecución

Ejecutar operación inicia una nueva operación. Activa Paso a paso antes de ejecutarla; navegar y cerrar el modo no repiten la operación.

Actual: +0.00x (1.00x real)

Paso 0 · sin función · sin fase · sin concepto

Paso: 0/0

2 Predecir

Activa preguntas, elige Paso a paso y prepara una operación. En las decisiones importantes podrás responder antes de ver el cambio.

Progreso conceptual de esta sesión: 0 predicciones.

4 Comprender

Referencia completa de la estructura

Estructura jerárquica secuencial: cada nodo padre mantiene su propia sublista de hijos. En la animación observa dos niveles de punteros (padres e hijos) y valida que cada operación afecte solo la rama correspondiente sin corromper otras sublistas. Listar hijos conserva la consulta exitosa en el historial tras recargar, sin volver a ejecutarla. El programa principal mostrado está completo: cópialo en main.c; ya incluye stdio.h y tad_sublista.h, y compila junto con el archivo C descargado. La aplicación copia como máximo 1024 hijos por consulta. El arreglo de consulta tiene capacidad suficiente según las inserciones previas; su contenido se obtiene ejecutando el C.

Frame actual: prepara una operación para observar concepto, cambio e invariante.

Condición y ciclo

Sin condición en este frame.

Variables C

Sin variables.

Punteros y enlaces

Sin cambios de punteros.

Heap y memoria

Sin objetos reservados.

Pila de llamadas

Sin llamadas.

5 Comparar conceptos

Selecciona una comparación para trabajar sobre dos copias independientes de la misma secuencia.

5 Resultados de ejecución

Ver y copiar main.c

Consola C (printf)

terminal

Seguimiento de operaciones

    Estructura del TAD

    typedef struct Sublista {
        int nro; /**< Dato entero almacenado. */
        struct Sublista *sgte; /**< Enlace al siguiente nodo. */
    } Sublista;
    
    typedef struct Nodo {
        int nro; /**< Dato entero almacenado. */
        struct Nodo *sgte; /**< Enlace al siguiente nodo. */
        Sublista *sub; /**< Cabeza de la sublista asociada. */
    } Nodo;