Cola de Prioridad

Laboratorio de memoria y punteros en C

Acerca de esta estructura

Los elementos se atienden por prioridad numérica.

1 Preparar

2 Visualizar y ejecutar

Código C: Encolar

/**
 * @brief Reserva e inicializa un nodo con enlace siguiente NULL.
 * @param valor Dato a almacenar.
 * @param prioridad Prioridad que se consulta al seleccionar la extracción.
 * @return Nodo reservado o NULL si falla malloc; el llamador adquiere su propiedad.
 * @note Enteros valor/prioridad admiten negativos y extremos int. Inicializa los tres campos; no imprime. Publicar en cola transfiere ownership; si no publica, caller debe liberar.
 */
static CPNodo *cp_crear_nodo(int valor, int prioridad) {
    CPNodo *nuevo = (CPNodo *)malloc(sizeof(CPNodo));
    if (nuevo == NULL) {
        return NULL;
    }
    nuevo->valor = valor;
    nuevo->prioridad = prioridad;
    nuevo->sgte = NULL;
    return nuevo;
}

/**
 * @brief Encola un elemento con su valor y prioridad asociada.
 * 
 * @details
 * Reserva dinámicamente un nuevo @c CPNodo, almacena @p valor y
 * @p prioridad en él y lo enlaza al extremo @c atras de la cola.
 * Si la cola estaba vacía, tanto @c delante como @c atras apuntarán
 * al nuevo nodo. El orden de extracción depende de la prioridad,
 * no del orden de inserción.
 * 
 * @param[in,out] cola      Puntero a la ColaPrioridad destino.
 * @param[in]     valor     Dato entero a almacenar.
 * @param[in]     prioridad Número de prioridad (menor valor = mayor prioridad).
 * 
 * @return @c true  si el nodo fue creado e insertado correctamente.
 * @return @c false si @p cola es NULL o @c malloc() falla.
 * 
 * @pre  La cola debe haber sido inicializada con cp_inicializar().
 * @post Si retorna true, el tamaño aumenta en 1; si retorna false, la cola no cambia.
 * @note Complejidad temporal: O(1).
 * @pre Cola propia consistente, nodos vivos y aciclicos; cantidad+1 cabe en int.
 * @note NULL cola o malloc fallido retorna false sin publicar nodo ni escribir enlaces. No reordena nodos; prioridad menor se selecciona al extraer.
 */
bool cp_encolar(ColaPrioridad *cola, int valor, int prioridad) {
    CPNodo *nuevo;
    if (cola == NULL) {
        return false;
    }

    nuevo = cp_crear_nodo(valor, prioridad);
    if (nuevo == NULL) {
        return false;
    }

    if (cola->delante == NULL) {
        cola->delante = nuevo;
    } else {
        cola->atras->sgte = nuevo;
    }
    cola->atras = nuevo;
    cola->cantidad++;
    return true;
}

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

Estructura FIFO por nivel de prioridad: se atiende primero el elemento con menor valor numérico de prioridad y, en empate, se conserva el orden de llegada. La inserción conserva el orden de llegada; la selección recorre la cadena y compara prioridades.

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 cp_nodo {
    int valor; /**< Dato almacenado. */
    int prioridad; /**< Prioridad del elemento. */
    struct cp_nodo *sgte; /**< Enlace al siguiente nodo. */
};

typedef struct cp_nodo CPNodo;

typedef struct {
    CPNodo *delante; /**< Primer nodo de la cola; NULL si está vacía. */
    CPNodo *atras; /**< Último nodo de la cola; NULL si está vacía. */
    int cantidad; /**< Número de elementos almacenados. */
} ColaPrioridad;