Lista Circular

Laboratorio de memoria y punteros en C

Acerca de esta estructura

Lista donde el último nodo vuelve al primero.

1 Preparar

2 Visualizar y ejecutar

Código C: Insertar inicio

/**
 * @brief Inserta un nuevo elemento al inicio de la lista circular.
 *
 * @param[in,out] lista Puntero a la lista.
 * @param[in]     valor Dato a insertar.
 *
 * @return true si se insertó; false si lista es NULL o malloc falla.
 * @post En éxito cantidad aumenta en uno y cola->sgte enlaza con cabeza.
 * @note Si falla la reserva, conserva cabeza, cola, cantidad y enlaces anteriores.
 *
 * @post Si la lista estaba vacía, el nodo apunta a sí mismo.
 * @note Complejidad temporal: O(1) ya que se mantiene el puntero a la cola.
 */
bool lcir_insertar_inicio(ListaCircular *lista, int valor) {
    LCirNodo *nuevo;

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

    nuevo = lcir_crear_nodo(valor);
    if (nuevo == NULL) {
        return false;
    }

    if (lista->cabeza == NULL) {
        nuevo->sgte = nuevo;
        lista->cabeza = nuevo;
        lista->cola = nuevo;
        lista->cantidad = 1;
        return true;
    }

    nuevo->sgte = lista->cabeza;
    lista->cola->sgte = nuevo;
    lista->cabeza = nuevo;
    lista->cantidad++;
    return true;
}

/**
 * @brief Crea un nuevo nodo para la lista circular.
 *
 * @param[in] valor Entero a almacenar en el nuevo nodo.
 *
 * @return Puntero al nuevo nodo, o NULL si la asignación de memoria falla.
 * @post En éxito valor contiene el dato y sgte es NULL; todavía no pertenece al anillo.
 * @note El llamador adquiere la propiedad de la reserva y debe publicarla o liberarla.
 *
 * @note Complejidad temporal: O(1).
 */
static LCirNodo *lcir_crear_nodo(int valor) {
    LCirNodo *nodo = (LCirNodo *)malloc(sizeof(LCirNodo));
    if (nodo == NULL) {
        return NULL;
    }
    nodo->valor = valor;
    nodo->sgte = NULL;
    return nodo;
}

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.

Interpretar código paso a paso

Velocidad de simulación

Actual: +0.00x (1.00x real)

Navegar por la traza

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.

Preguntas predictivas Modo práctica: ocultar pistas y resultados

Progreso conceptual de esta sesión: 0 predicciones.

4 Comprender

Referencia completa de la estructura

Lista enlazada circular donde el último nodo apunta nuevamente al primero. La interpretación paso a paso muestra cada escritura; el cierre del ciclo se restablece al terminar cada alta/baja de nodos para evitar rupturas o ciclos inválidos.

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

struct lcir_nodo {
    int valor; /**< Dato almacenado. */
    struct lcir_nodo *sgte; /**< Enlace al siguiente nodo. */
};

typedef struct lcir_nodo LCirNodo;

typedef struct {
    LCirNodo *cabeza; /**< Primer nodo del anillo; NULL si está vacío. */
    LCirNodo *cola; /**< Último nodo del anillo; NULL si está vacío. */
    int cantidad; /**< Número de elementos almacenados. */
} ListaCircular;