4

ESTRUCTURAS DE DATOS (I):

ARRAYS

En capítulos anteriores se ha estudiado el concepto de datos de tipo simple (entero, real y

carácter). A veces, los datos a tratar en un programa no son elementos individuales de información,
sino que existe cierta relación entre ellos. En esos casos, los lenguajes de programación permiten
trabajar con estructuras de datos, es decir, colecciones de datos más simples con relaciones
establecidas entre ellos. Estas estructuras de datos posibilitan, por un lado, representar la
información de una manera más natural y clara y, por otro, un tratamiento de la información más
cómodo y eficiente. En este capítulo se tratará una de las estructuras de datos más habituales en
programación: los arrays.

4.1 INTRODUCCIÓN
Una estructura de datos es una colección de datos caracterizada por su organización y por las
operaciones definidas sobre ella. Los tipos de datos utilizados para declarar estructuras de datos se
denominan tipos compuestos y se construyen a partir de los tipos simples ya estudiados.
Distinguimos dos categorías de estructuras de datos:
 Estáticas: su tamaño se determina a priori, antes del comienzo de la ejecución del programa,
y este no podrá incrementarse ni disminuirse en tiempo de ejecución. Esto implicará que
cuando se trabaje con una estructura de datos estática cuyo tamaño se desconoce en la fase
de diseño, será necesario establecer un tamaño máximo y reservar espacio en memoria para
ese máximo (con el posible desperdicio de memoria que esto pueda conllevar). Entre las
estructuras de datos estáticas distinguimos arrays, cadenas de caracteres y registros.
 Dinámicas: su tamaño se determina en tiempo de ejecución, reservando y liberando espacio
en memoria en el momento que interese. Esto permitirá, por tanto, optimizar al máximo el
espacio de ocupación en memoria, aunque requiere una gestión de memoria más complicada.
Se distinguen listas, árboles y grafos.
En esta asignatura nos centraremos en las estructuras de datos estáticas, adecuadas como una
primera aproximación al manejo de estructuras de datos por ser más sencillas de gestionar.
Una característica común a todas las estructuras de datos es la existencia de un único
identificador que hace referencia a la misma en su conjunto. Además, cada tipo de estructura de

44
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

datos dispone de su propio mecanismo para hacer referencia de forma independiente a los
elementos que la integran.

4.2 ARRAYS
Un array es una colección de elementos de un mismo tipo, donde cada elemento puede
identificarse por su posición dentro de la estructura. Todo array posee un identificador que lo
designa y una serie de índices que toman valores enteros y permiten diferenciar por su posición a
los distintos elementos que lo constituyen.

4.2.1 ARRAYS UNIDIMENSIONALES

Un array unidimensional puede considerarse como una lista ordenada de valores. Lleva asociado
un único índice que designa la posición de los valores dentro de la lista, comenzando en lenguaje C
desde 0. Debido a su similitud con el concepto matemático de vector, los arrays unidimensionales
también se conocen con el nombre de vectores.
En la siguiente figura se representa gráficamente un vector que representa el número de
habitantes (en unidades de millar) de 100 poblaciones:
0 1 2 99
habitantes 30 7 5 ... 120

Para hacer referencia a cada elemento del vector, tanto en algoritmia como en C, se utiliza la
siguiente sintaxis:
identificador[índice]
Por ejemplo, el número de habitantes de la tercera población se designa habitantes[2] y su
contenido es igual a 5.
En algoritmia, la declaración de estructuras de datos de tipo vector utiliza el siguiente diagrama
sintáctico:

identificador valor de
VARIABLES [ ] : tipo
de variable tipo entero
,
El valor de tipo entero representa el número de elementos del vector y, por tanto, determina el
rango de valores que puede tomar el índice (en C, desde 0 a valor de tipo entero – 1, ambos
inclusive).

La traducción a C de esta declaración se realiza según el siguiente diagrama sintáctico:

identificador [ valor de ] ;
tipo
de variable tipo entero
,

45
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

Por ejemplo, las declaraciones del vector habitantes en algoritmia y en C emplearían la

siguiente sintaxis:
En algoritmia: En C:
VARIABLES int habitantes[100];
habitantes[100]:entero

EJEMPLO 4.1. A partir de las edades de 10 individuos introducidas por teclado, calcular y mostrar cuántos
individuos son mayores y cuántos menores que la media.
ANÁLISIS:
a) Datos de entrada:
 NUMIND=10. Número de individuos. Dato fijo.
 edad[1..NUMIND]: Edades de los individuos. Teclado. (edad[i] ≥ 0, ∀i)
b) Datos de salida:
 may: Número de individuos con edad superior a la media de edad[1..NUMIND]. Monitor.
 men: Número de individuos con edad inferior a la media de edad[1..NUMIND]. Monitor.
c) Comentarios:
 Dado que, una vez calculada la media de las edades, será necesario recorrer de nuevo la lista de edades, se
utilizará un vector para representar dicha lista.
 Se utilizará una variable índice para recorrer el vector, en primer lugar, para almacenar los valores en él
durante la lectura desde teclado y el cálculo de la media y, en segundo lugar, para determinar cuántos de
esos valores son mayores y cuántos menores que la media.
 Se utilizará una variable para acumular los valores del vector durante el cálculo de la media.
 Se utilizará una variable para almacenar el resultado de la media.
DISEÑO:
a) Parte declarativa:
CONSTANTES
NUMIND=10
VARIABLES
edad[NUMIND]:entero
med:real
i,suma,may,men:entero
b) Representación algorítmica:
contar
BLOCK

suma←0 for do med←suma/NUMIND men←0 may←0 for do escribir

(may,men)

i ← 0,NUMIND-1,1 BLOCK i ← 0,NUMIND-1,1 if then else

escribir leer while do suma←suma+edad[i] edad[i] < med men←men+1 if then

("Edad",i+1) (edad[i])

edad[i] < 0 BLOCK edad[i] > med may←may+1

escribir escribir leer

("Error") ("Edad",i+1) (edad[i])

46
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

CODIFICACIÓN:
/*************************/
/*** E D A D E S ***/
/*************************/
#include <stdio.h>

#define NUMIND 10 /* Número de individuos (edades) */

int main()
{
int edad[NUMIND];
double med;
int i,suma,may,men;

/* Lectura desde teclado del vector y cálculo de la media */

suma=0;
for (i=0; i <= NUMIND-1; i=i+1)
{
printf("Edad %d: ",i+1);
scanf("%d",&edad[i]);
while (edad[i] < 0)
{
printf("Error, debe ser mayor o igual que cero.\n");
printf("Edad %d: ",i+1);
scanf("%d",&edad[i]);
}
suma=suma+edad[i];
}
med=(double)suma / NUMIND;

/* Cálculo de número de valores superiores e inferiores a la media */

men=0;
may=0;
for (i=0; i <= NUMIND-1; i=i+1)
if (edad[i] < med)
men=men+1;
else
if (edad[i] > med)
may=may+1;

/* Visualización de resultados */
printf("Número de individuos mayores que la media: %d.\n",may);
printf("Número de individuos menores que la media: %d.\n",men);
return 0;
}

4.2.2 ARRAYS MULTIDIMENSIONALES

A veces, existen datos cuya representación es más adecuada en forma de tabla con dos o más
índices, por ejemplo, para tratar la disposición de las fichas en un tablero de ajedrez (8×8 casillas) o
valores diarios durante los meses de una década (31×12×10 valores). Para ello, se pueden emplear
arrays multidimensionales.
Un array bidimensional (también denominado matriz) puede considerarse como un array
organizado en filas y columnas. Así, por ejemplo, el censo de 100 poblaciones durante 3 décadas
podría representarse mediante una matriz de dimensiones 100×3, como se muestra a continuación:
habitantes Índice de década
0 1 2
0 31 28 30
Índice de 1 10 8 7
población ... ... ... ...
99 60 90 120

47
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

Para referenciar a cada elemento de un array bidimensional se utilizan dos índices. El primero se
refiere a la fila y el segundo a la columna que ocupa dicho elemento. Se utiliza la siguiente sintaxis:
identificador[fila][columna]
Por ejemplo, el número de habitantes de la segunda población en el censo de la primera década
se designa habitantes[1][0] y su contenido es igual a 10.
Análogamente, pueden declararse arrays de tantas dimensiones como se quiera, teniendo como
limitación el tamaño de la memoria del ordenador. El número total de elementos del array es el
producto del número de elementos de cada dimensión. Por ejemplo, un array de dimensión 3×10×2
tendrá 60 elementos. No obstante, a mayor número de dimensiones, menor será la legibilidad de la
solución y mayor la dificultad de su manejo, pues cada índice hará referencia a una característica de
los datos y debemos saber en qué orden debe situarse cada uno de los índices (por ejemplo, primero
el código de población, a continuación la década, etc.).
En general, un elemento de un array n-dimensional se referencia con la siguiente sintaxis:
identificador[índice1][índice2]...[índicen]
Al igual que en el caso de los vectores, todos los elementos de un array multidimensional deben
ser de igual tipo. Si junto con el número de habitantes del ejemplo anterior quisiéramos almacenar
el nombre de la entidad que realizó el censo (representado por un dato de tipo cadena de
caracteres), sería preciso declarar una nueva matriz de tamaño 100×3 en vez de añadir una nueva
dimensión al array original, ya que los datos a almacenar son de distinto tipo1.
En algoritmia, la declaración de una estructura de datos array multidimensional utiliza el
siguiente diagrama sintáctico:

identificador valor de
VARIABLES [ ] : tipo
de variable tipo entero
,
Ahora, cada valor de tipo entero representa el número de elementos de la dimensión
correspondiente y, por tanto, el rango de valores que puede tomar su índice (en C, desde 0 a valor
de tipo entero – 1).
La traducción a C de esta declaración se realiza según el siguiente diagrama sintáctico:

identificador [ valor de ] ;
tipo
de variable tipo entero
,
Por ejemplo, la declaración de la matriz habitantes vista anteriormente emplearía la
siguiente sintaxis:
En algoritmia: En C:
VARIABLES int habitantes[100][3];
habitantes[100][3]:entero

1 Veremos en el Capítulo 6 que existe una alternativa más adecuada mediante el uso de registros.

48
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

EJEMPLO 4.2. Almacenar desde teclado valores reales en una matriz de dimensiones 20x20 por filas y mostrar por
pantalla la suma de sus columnas.
ANÁLISIS:
a) Datos de entrada:
 NUMFIL=5. Número de filas. Dato fijo.
 NUMCOL=5. Número de columnas. Dato fijo.
 m[1..NUMFIL][1..NUMCOL]: Matriz de números reales. Teclado.
b) Datos de salida:
 s[1..NUMCOL]: Sumas de las columnas de la matriz. Monitor.
c) Comentarios:
 Se utilizarán dos variables índice para recorrer la matriz, en primer lugar, durante su lectura desde teclado y,
en segundo, durante el cálculo de la suma de cada columna.
 Dado que se mostrará la suma de cada columna tras su cálculo, no es necesario recordar simultáneamente
cada una de ellas, por lo que solo se utilizará una variable para almacenarlas.
DISEÑO:
a) Parte declarativa:
CONSTANTES
NUMFIL=5
NUMCOL=5
VARIABLES
m[NUMFIL][NUMCOL]:real
i,j:entero
s:real
b) Representación algorítmica:
sumaColumnas
BLOCK

for do for do

i←0,NUMFIL-1,1 BLOCK j←0,NUMCOL-1,1 BLOCK

escribir("Fila",i+1) for do s←0 for do escribir(s)

j←0,NUMCOL-1,1 leer(m[i][j]) i←0,NUMFIL-1,1 s←s+m[i][j]

CODIFICACIÓN:
/***************************************/
/*** S U M A C O L U M N A S ***/
/***************************************/
#include <stdio.h>

#define NUMFIL 5 /* Número de filas de la matriz */

#define NUMCOL 5 /* Número de columnas de la matriz */
int main()
{
double m[NUMFIL][NUMCOL],s;
int i,j;

/* Lectura desde teclado de la matriz por filas */

for (i=0; i <= NUMFIL-1; i=i+1)
{
printf("Fila %d: ",i+1);
for (j=0; j <= NUMCOL-1; j=j+1)

49
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

scanf("%lf",&m[i][j]);
}

/* Cálculo de la suma de cada columna y visualización de resultados */

for (j=0; j <= NUMCOL-1; j=j+1)
{
s=0;
for (i=0; i <= NUMFIL-1; i=i+1)
s=s+m[i][j];
printf("La suma de la columna %d es %.2f.\n",j+1,s);
}
return 0;
}

50
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

EJERCICIOS

1º) Leer desde teclado un vector con n números enteros y a continuación indicar por pantalla si
este es capicúa, siendo n un número entre 2 y 100, también leído desde teclado.
2º) Leer desde teclado un vector con 10 números enteros y a continuación indicar por pantalla si el
valor de algún elemento coincide con la suma de todos los que están a su izquierda en el
vector.
3º) Leer desde teclado una matriz con 5×4 valores reales y a continuación mostrar su traspuesta.
4º) Leer desde teclado dos matrices A y B de dimensiones 5×4 y 4×6, respectivamente, con valores
reales y mostrar el resultado de A×B.
5º) Leer desde teclado una matriz con 6×6 valores reales positivos y dos valores a y b, y mostrar la
media de los elementos de la matriz que sean mayores que a y menores que b.
6º) Leer desde teclado una secuencia de 10 valores reales y mostrar el número de orden (posición)
en la secuencia de los valores menores que la media y el número total de valores mostrados.
7º) Generar aleatoriamente un vector de m dígitos y leer desde teclado una lista con n índices del
vector, donde m y n se introducen por teclado y donde 10 ≤ m ≤ 30. A continuación, mostrar el
vector generado y el valor del vector que más se aproxima a la media de los elementos
apuntados por la lista de índices.
Nota: Para generar números aleatorios debe utilizarse la función interna rand(), que genera
un número aleatorio de tipo entero en el intervalo [0, 32767]. Antes de utilizar esta función en
el programa será necesario invocar una vez a la función interna srand(time(NULL)); que
inicializa el generador de números aleatorios a partir de la hora actual del sistema, para evitar
así que siempre se genere la misma secuencia de números aleatorios. Para el uso de ambas
funciones es necesario incluir los archivos de cabecera stdlib.h y time.h.
8º) Leer desde teclado y almacenar en una matriz una serie de temperaturas tomadas cada hora
durante una semana. A continuación, mostrar por pantalla la máxima de las temperaturas
mínimas diarias.
9º) Generar aleatoriamente un array tridimensional de 5×10×3 con valores entre el 1 y el 40 y
mostrar por pantalla el array generado, el valor del array que más veces se repite y el número
de repeticiones del mismo (si hay varios valores que se repiten el número máximo de veces,
devolver uno de ellos cualquiera).
10º) La distancia entre dos valores x e y se calcula como el valor absoluto de su diferencia |x-y|.
Realizar el análisis, diseño y codificación de un programa en C que lea desde teclado n valores
reales dentro del intervalo [1,n2], donde 5 ≤ n ≤ 30, y a continuación muestre por pantalla la
distancia mínima entre dos valores de posiciones distintas de entre todos los pares posibles.
11º) Realizar el análisis, diseño y codificación en C de un programa que muestre en pantalla 100
números enteros aleatorios que deberán estar entre dos números (el primero será un número
introducido por teclado que deberá estar entre el 5 y el 100, y el segundo será el 1000).
Además los números que aparezcan en pantalla no deberán estar repetidos.
12º) Realizar el análisis, diseño y codificación en C de un programa que genere aleatoriamente una
matriz de 5 filas y 10 columnas con valores enteros entre el 1 y el 5, lea un valor n desde

51
CURSO 2019/20 4. ESTRUCTURAS DE DATOS (I): ARRAYS

teclado y muestre por pantalla la matriz y un mensaje que indique si existe en ella alguna
columna que sume n y, en caso positivo, el índice de la primera columna que cumpla la
condición.
13º) Realizar el análisis, diseño y codificación en C de un programa que rellene un vector de 20
reales a partir de una secuencia de números organizados en pares (a,b). El primer número a de
cada par indica el valor que debe introducirse en el vector y será un número real mayor o igual
que cero introducido por teclado. El segundo número b de cada par especifica la cantidad de
valores que deben introducirse en el vector y será generado de manera aleatoria en el intervalo
[1,10]. Finalmente, una vez que el vector esté completamente relleno, su contenido deberá
mostrarse por pantalla.
14º) Realizar el análisis, diseño y codificación en C de un programa que:
a) en primer lugar, lea desde teclado un máximo de 30 valores reales entre 1 y 40,
almacenando los valores de nº de orden par (segundo, cuarto, sexto, etc.) en un vector y los
de orden impar (primero, tercero, quinto, etc.) en otro vector. La lectura de valores
finalizará cuando se llegue a 30 valores o se introduzcan dos valores iguales en la misma
posición de sendos vectores (sean iguales el primero y el segundo, o el tercero y el cuarto, o
el quinto y el sexto, etc).
b) en segundo lugar, una vez finalizada la lectura desde teclado, calcular y mostrar por pantalla
la distancia mayor entre pares de valores situados en la misma posición en sendos vectores.
Importante: el cálculo de la distancia descrito en el apartado b no deberá comenzar antes de
que haya finalizado la lectura descrita en el apartado a.

52