Colecciones ordenadas con listas/arreglos: secuencia, índices y recorridos

¿Qué es una lista/arreglo y cuándo conviene usarla?

Una lista (o arreglo) es una colección ordenada de elementos. “Ordenada” significa que cada elemento ocupa una posición específica dentro de una secuencia. Es ideal cuando necesitas agrupar muchos datos del mismo dominio y trabajar con ellos como conjunto, por ejemplo: calificaciones de un estudiante, productos en un carrito, lecturas de sensores, temperaturas por día.

• Mismo dominio: elementos comparables o del mismo tipo lógico (números, textos, registros).
• Orden importa: el primer elemento no es lo mismo que el último; la posición tiene significado (día 1, día 2, etc.).
• Acceso posicional: puedes leer un elemento indicando su índice.

Ejemplos de listas

calificaciones = [18, 15, 20, 12]          // notas en orden de evaluación 1..n (según tu criterio) productos = ["pan", "leche", "arroz"]     // lista de compras temperaturas = [22.1, 21.8, 23.0, 24.2] // lecturas en orden temporal

Índices, longitud y acceso posicional

Para usar listas con seguridad necesitas dominar tres ideas: índice, longitud y rango válido.

Índice

El índice es el número que identifica la posición de un elemento. En muchos lenguajes se usa índice desde 0 (cero), así que el primer elemento está en la posición 0. En otros contextos se enseña desde 1. En este capítulo usaremos índices desde 0 para el pseudocódigo.

productos = ["pan", "leche", "arroz"] índice:        0        1        2

Longitud

La longitud (o tamaño) es la cantidad de elementos.

n = longitud(productos)   // n = 3

Acceso posicional

Acceder es pedir “el elemento en la posición i”.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

primero = productos[0]   // "pan" segundo  = productos[1]   // "leche" ultimo  = productos[longitud(productos) - 1]  // "arroz"

Error común: índice fuera de rango

Un error típico ocurre cuando intentas acceder a una posición que no existe. El rango válido de índices es: 0 hasta longitud(lista) - 1.

productos = ["pan", "leche", "arroz"] x = productos[3]   // ERROR: el último índice válido es 2

También es común equivocarse al recorrer con un límite incorrecto:

// MAL: i llega a longitud(lista), que es un índice inválido Para i desde 0 hasta longitud(productos) hacer     imprimir(productos[i]) FinPara

// BIEN: el último índice es longitud(lista) - 1 Para i desde 0 hasta longitud(productos) - 1 hacer     imprimir(productos[i]) FinPara

Guía práctica paso a paso: trabajar con una lista

Paso 1: define qué representa el orden

Antes de programar, decide qué significa la posición. Ejemplos:

• Temperaturas: índice 0 = primer día registrado.
• Calificaciones: índice 0 = primera evaluación.
• Carrito: índice 0 = primer producto agregado (orden de inserción).

Paso 2: crea la lista con datos de ejemplo

temperaturas = [22.1, 21.8, 23.0, 24.2]

Paso 3: consulta longitud y últimos elementos sin fallar

n = longitud(temperaturas) ultimo = temperaturas[n - 1]

Paso 4: recorre la lista para calcular algo útil

suma = 0 Para i desde 0 hasta longitud(temperaturas) - 1 hacer     suma = suma + temperaturas[i] FinPara promedio = suma / longitud(temperaturas)

Patrones de recorrido (iteración) en pseudocódigo

Recorrer una lista es una de las operaciones más frecuentes. A continuación se muestran patrones reutilizables.

1) Iteración completa (visitar todos los elementos)

Útil para imprimir, sumar, contar, validar, etc.

Para i desde 0 hasta longitud(lista) - 1 hacer     elemento = lista[i]     // usar elemento FinPara

Ejemplo: contar cuántas calificaciones son aprobatorias (>= 11).

aprobados = 0 Para i desde 0 hasta longitud(calificaciones) - 1 hacer     Si calificaciones[i] >= 11 entonces         aprobados = aprobados + 1     FinSi FinPara

2) Búsqueda lineal (encontrar un elemento)

La búsqueda lineal revisa uno por uno hasta encontrar lo buscado o terminar la lista. Funciona aunque la lista no esté ordenada.

Funcion buscarIndice(lista, objetivo)     Para i desde 0 hasta longitud(lista) - 1 hacer         Si lista[i] == objetivo entonces             retornar i         FinSi     FinPara     retornar -1  // no encontrado FinFuncion

Ejemplo: buscar un producto en una lista de compras.

i = buscarIndice(productos, "leche") Si i != -1 entonces     imprimir("Está en la posición: " + i) SiNo     imprimir("No está en la lista") FinSi

3) Filtrado (quedarse con los que cumplen una condición)

Filtrar crea una nueva lista con elementos que pasan un criterio.

Funcion filtrarMayoresQue(lista, umbral)     resultado = []     Para i desde 0 hasta longitud(lista) - 1 hacer         Si lista[i] > umbral entonces             agregarAlFinal(resultado, lista[i])         FinSi     FinPara     retornar resultado FinFuncion

Ejemplo: temperaturas mayores a 23.

altas = filtrarMayoresQue(temperaturas, 23.0)

4) Transformación (mapear: convertir cada elemento en otro)

Mapear produce una nueva lista donde cada elemento es el resultado de aplicar una regla a cada elemento original.

Funcion mapear(lista, regla)     resultado = []     Para i desde 0 hasta longitud(lista) - 1 hacer         nuevo = regla(lista[i])         agregarAlFinal(resultado, nuevo)     FinPara     retornar resultado FinFuncion

Ejemplo: convertir temperaturas de °C a °F.

Funcion celsiusAFahrenheit(c)     retornar (c * 9/5) + 32 FinFuncion temperaturasF = mapear(temperaturas, celsiusAFahrenheit)

Operaciones típicas y costo lógico (impacto en el diseño)

Además de recorrer, en listas se suele leer por índice, insertar y eliminar. El “costo lógico” describe cómo crece el trabajo cuando la lista tiene más elementos (n).

Cómo estas decisiones impactan tu solución

• Si necesitas muchas lecturas por posición (ej. “dame el elemento 20”), la lista es adecuada.
• Si necesitas muchas inserciones/eliminaciones en medio (ej. mantener una cola de espera con cambios constantes), una lista simple puede volverse costosa; quizá convenga replantear el modelo (por ejemplo, agregar al final y marcar, o usar otra estructura).
• Si el problema es “encontrar algo” repetidamente, una lista obliga a buscar linealmente; podrías considerar estructuras con acceso por clave en otro capítulo, o mantener la lista ordenada y usar búsqueda más eficiente (si aplica).

Actividades de modelado (del enunciado a la lista)

Actividad 1: Lista de compras

Enunciado: “Necesito registrar productos para comprar, tachar los que ya compré y verificar si falta alguno.”

Modelado:

• Lista: compras = ["pan", "leche", "arroz", "huevos"]
• Operaciones necesarias:
• Agregar producto al final: agregarAlFinal(compras, "café")
• Buscar un producto: buscarIndice(compras, "leche")
• Eliminar un producto comprado (por índice): eliminarEn(compras, i)
• Recorrer para mostrar todo: iteración completa.

Reto: escribe pseudocódigo para “si el producto existe, eliminarlo; si no existe, avisar”.

Actividad 2: Historial de temperaturas

Enunciado: “Guardo temperaturas diarias y necesito calcular promedio, máximos y días con alerta.”

Modelado:

• Lista: temperaturas = [22.1, 21.8, 23.0, 24.2, 25.0]
• Operaciones necesarias:
• Promedio: recorrer y sumar.
• Máximo: recorrer y comparar.
• Filtrar alertas: crear lista con valores > umbral.
• Transformar unidades: mapear °C a °F.

Reto: crea una lista alertas con las posiciones (índices) donde la temperatura supera 24.0.

Actividad 3: Lecturas de sensores (secuencia temporal)

Enunciado: “Un sensor envía lecturas cada minuto. Quiero quedarme con las lecturas válidas (no negativas) y convertirlas a otra escala.”

• Lista: lecturas = [0.2, -1.0, 0.5, 0.7, -0.3, 1.1]
• Operaciones necesarias:
• Filtrar válidas: condición >= 0.
• Mapear escala: multiplicar por un factor.
• Evitar errores: recorrer usando 0..longitud-1.