En los lenguajes de programación, un array (o arreglo) es una estructura de datos que almacena varios elementos de un mismo tipo en posiciones contiguas de memoria. Por ejemplo, un array puede contener sólo enteros o sólo cadenas. Cada elemento del array se identifica por un índice numérico que permite al programador acceder directamente a ese elemento. En muchos lenguajes el primer elemento tiene índice 0 (0, 1, 2, ...), aunque existen lenguajes cuyo índice inicial es 1 (1, 2, 3, ...).

Características principales

  • Tamaño fijo (en arrays estáticos): al crear el array normalmente se especifica el tamaño, es decir, cuántos elementos puede contener. Ese tamaño no puede cambiarse en arrays estáticos; para almacenar más elementos se crea un nuevo array de mayor tamaño y se copian los datos.
  • Acceso por índice: acceso directo (O(1)) a cualquier elemento usando su índice.
  • Almacenamiento contiguo: en la mayoría de implementaciones los elementos se guardan en posiciones contiguas de memoria, lo que facilita el cálculo de la dirección de cada elemento.
  • Elementos del mismo tipo: los arrays clásicos requieren elementos del mismo tipo; algunos lenguajes dinámicos permiten colecciones heterogéneas (listas) que se comportan de forma parecida.

Tipos de arrays

  • Unidimensionales: una secuencia lineal de elementos (el más común).
  • Multidimensionales: arrays con dos o más dimensiones (p. ej., matrices 2D, 3D). Internamente pueden representarse como arrays de arrays o como una estructura plana con cálculo de índice.
  • Jagged (irregulares): arrays de arrays donde las subfilas pueden tener longitudes diferentes (por ejemplo, en Java: int[][] con subarrays de distinto tamaño).
  • Estáticos vs dinámicos: arrays estáticos tienen tamaño fijo (C, arrays nativos en muchos lenguajes), mientras que estructuras dinámicas (vectores, listas dinámicas) permiten crecer o reducirse automáticamente (std::vector en C++, ArrayList en Java, listas en Python).
  • Asociativos (mapas/diccionarios): no son arrays indexados por números secuenciales, pero conceptualmente sirven para asociar claves a valores (p. ej., diccionarios en Python, HashMap en Java).

Índices, límites y errores comunes

  • Índice base: algunos lenguajes usan base 0 (C, C++, Java, JavaScript, Python), otros usan base 1 por defecto (Matlab, R, Fortran en ciertos modos) o permiten definir rangos (Pascal).
  • Out-of-bounds: acceder con un índice fuera del rango válido causa errores: en C/C++ produce comportamiento indefinido; en Java o Python lanza una excepción (ArrayIndexOutOfBoundsException, IndexError).
  • Longitud/propiedad: muchos lenguajes ofrecen una propiedad o función para obtener la longitud del array (p. ej., .length en Java, len() en Python).

Operaciones comunes

  • Acceso y lectura de elementos por índice.
  • Asignación/actualización de valores en una posición concreta.
  • Recorrido (iteración) para procesar todos los elementos.
  • Búsqueda (lineal, binaria si está ordenado).
  • Inserción y eliminación: en arrays estáticos estas operaciones implican mover elementos y pueden ser costosas (O(n)); en estructuras dinámicas suelen abstraerse y optimizarse.

Ejemplos básicos

Ejemplo en C (array unidimensional):

int a[5];         /* declara un array de 5 enteros */ a[0] = 10;          /* asigna al primer elemento */ int x = a[0];       /* lee el primer elemento */

Ejemplo en Java:

int[] a = new int[5];  // declara e inicializa a 0 a[0] = 10; int x = a[0];

Ejemplo en Python (lista, similar a un array dinámico):

a = [0] * 5     # lista de 5 elementos a[0] = 10 x = a[0] a.append(20)       # crece dinámicamente

Ventajas y desventajas

  • Ventajas: acceso aleatorio rápido, estructura simple, uso eficiente de memoria si el tamaño es conocido.
  • Desventajas: tamaño fijo en arrays estáticos, inserciones/eliminaciones costosas en posiciones intermedias, riesgo de errores por índices fuera de rango.

Buenas prácticas

  • Comprobar límites antes de acceder para evitar errores.
  • Usar estructuras dinámicas (vectores, listas) cuando el tamaño debe cambiar frecuentemente.
  • Preferir tipos de datos y colecciones adecuados al lenguaje (por ejemplo, arrays primitivos en C para rendimiento; ArrayList o Vector en Java según concurrencia).
  • Documentar la convención de índices (si se usa base 0 o 1) en código colaborativo.

Para aprender más sobre implementaciones y tipos de arrays en C, consulte documentación y ejemplos específicos del lenguaje, ya que C ofrece arrays unidimensionales, multidimensionales y la posibilidad de manipular memoria con punteros para estructuras avanzadas.