ESTRUCTURAS DE DATOS ESTATICAS

Una estructura de datos es la colección de datos que se caracterizan por su organización

y las operaciones que se definen en ella. Los datos de tipo estándar pueden ser
organizados en diferentes estructuras de datos: estáticas y dinámicas.

Las estructuras estáticas son aquellos en las que el espacio ocupado en memoria se
define en tiempo de compilación y no puede ser modificado durante la ejecución del
programa; por el contrario, en las estructuras de datos dinámicas el espacio ocupado en
memoria puede ser modificado en tiempo de ejecución.

Podemos enumerar como estructuras estáticas :

• Los arreglos.
• Los registros.

Y en las estructuras dinámicas:

• Las listas
• Los árboles
• Los grafos.

La elección de la estructura de datos idónea dependerá de la naturaleza del problema a

resolver y en menor medida, del lenguaje. Las estructuras de datos tienen en común que
un identificador, nombre, puede representar a múltiples datos individuales.

Las estructuras estáticas denominadas arreglos, las podemos definir como la colección de
datos del mismo tipo, que se almacenan en posiciones consecutivas de memoria y
reciben un nombre común. Para referirse a un determinado elemento de un arreglo se
deberá utilizar un índice, que especifique la posición relativa en el arreglo. Los arreglos
pueden ser:

• Unidimensionales: Denominados también vectores

• Bidimensionales: También llamadas tablas o matrices
• Multidimensionales: con tres o más dimensiones

Unidimensional

Bidimensionales
Posición contenido
0 Elemento 0
1 Elemento 1 0 1 N
2 Elemento 2 0 Elemento 0,0 ………. Elemento 0,n

3 1 Elemento 1,0 ……….. Elemento 1,n

Elemento 3
2 Elemento 2,0 ……….. Elemento 2,n
m Elemento m
m Elemento m,0 ………… Elemento m,n
Dimensión del vector m posiciones

Dimensión de la matriz (m x n) posiciones

Tridimensional
 ARREGLOS UNIDIMENSIONALES: VECTORES

DECLARACION

El formato para declarar un arreglo Unidimensional es:

Tipo de dato nombre_arr [ tamaño ]

Por ejemplo, para declarar un arreglo de enteros llamado listanum con diez elementos se
hace de la siguiente forma:

int listanum[10];

En C, todos los arreglos usan cero como índice para el primer elemento. Por tanto, el
ejemplo anterior declara un arreglo de enteros con diez elementos desde listanum[0]
hasta listanum[9].

ACCESO

La forma como pueden ser accesados los elementos de un arreglo, es de la siguiente

forma:

listanum[2] = 15; /* Asigna 15 al 3er elemento del arreglo listanum*/

Num = listanum[2]; /* Asigna el contenido del 3er elemento a la variable num */

El lenguaje C no realiza comprobación de contornos en los arreglos. En el caso de que

sobrepase el final durante una operación de asignación, entonces se asignarán valores a
otra variable o a un trozo del código, esto es, si se dimensiona un arreglo de tamaño N, se
puede referenciar el arreglo por encima de N sin provocar ningún mensaje de error en
tiempo de compilación o ejecución, incluso aunque probablemente se provoque el fallo del
programa. Como programador se es responsable de asegurar que todos los arreglos sean
lo suficientemente grandes para guardar lo que pondrá en ellos el programa.
Pues bien, supongamos que tenemos guardado en el computador la temperatura que ha
hecho cada hora del día. Ahora vamos a ver qué pasa si intentamos imprimir más
elementos de los que hay en el vector, en este caso intentamos imprimir 28 elementos
cuando sólo hay 24:

#include <stdio.h>
#include <conio.h>

main()
{
int hora;
/* Faltan los tres últimos elementos */
int temperaturas[24] = { 15, 18, 20, 23, 22, 24, 22, 25, 26, 25, 24,
22, 21, 20, 18, 17, 16, 17, 15, 14, 14, 13, 13, 12 };

for (hora=0 ; hora<28 ; hora++ )

{
printf( "La temperatura a las %d era de %d grados.\n", hora, temperaturas[hora] );
}
getch();
}

Lo que se obtiene en mi computador es:

La temperatura a las 22 era de 15 grados.

...
La temperatura a las 23 era de 12 grados.
La temperatura a las 24 era de 24 grados.
La temperatura a las 25 era de 3424248 grados.
La temperatura a las 26 era de 7042 grados.
La temperatura a las 27 era de 1 grados.

Vemos que a partir del elemento 24 (incluído) tenemos resultados extraños. Esto es
porque nos hemos salido de los límites del arreglo e intenta acceder al elemento
temperaturas[25] y sucesivos que no existen. Así que nos muestra el contenido de la
memoria que está justo detrás de temperaturas[23] (esto es lo más probable) que puede
ser cualquiera. Al contrario que otros lenguajes C no comprueba los límites de los arreglo.
Este programa no da error al compilar ni al ejecutar, tan sólo devuelve resultados
extraños. Tampoco bloqueará el sistema porque no estamos escribiendo en la memoria
sino leyendo de ella.

Otra cosa muy diferente es meter datos en elementos que no existen. Veamos un ejemplo
(ni se te ocurra ejecutarlo):

#include <stdio.h>
#include <conio.h>

main()
{
int temp[24];
float media = 0;
int hora;

for( hora=0; hora<28; hora++ )

{
printf( "Temperatura de las %i: ", hora );
scanf( "%i", &temp[hora] );
media += temp[hora];
}
media = media / 24;

printf( "\nLa temperatura media es %f\n", media );

getch();
}

Lo que sospechaba, lo he probado en mi computador y se ha bloqueado. He tenido que

apagarlo. El problema ahora es que estamos intentando escribir en el elemento temp[24]
que no existe y puede ser un lugar cualquiera de la memoria. Como consecuencia de esto
podemos estar cambiando algún programa o dato de la memoria que no debemos y el
sistema se bloquea. Así que mucho cuidado con esto.

PASO DE UN ARREGLO A UNA FUNCIÓN

El nombre de un arreglo se puede usar como argumento de una función, permitiendo así
que el arreglo completo sea pasado a la función. Sin embargo la manera en que se pasa
difiere mucho de la de una variable ordinaria.

Para pasar un arreglo a una función, el nombre del arreglo debe aparecer sólo, sin
corchetes o índices, como un argumento actual dentro de la llamada a la función. El
correspondiente argumento formal se escribe de la misma manera, pero debe ser
declarado como un arreglo dentro de la declaración de argumentos formales. Cuando se
declara un arreglo unidimensional como un argumento formal, el arreglo se escribe con un
par de corchetes vacíos.

Hemos visto que los argumentos son pasados a la función por valor cuando los
argumentos son variables ordinarias. Sin embargo, cuando se pasa un arreglo a una
función, los valores de los elementos del arreglo no son pasados a la función. En vez de
esto, el nombre del arreglo se interpreta como la dirección del primer elemento del arreglo
(puntero del arreglo). Los argumentos pasados de esta forma se dicen que son pasados
por referencia en vez de por valor. Por tanto, si un elemento del arreglo es alterado dentro
de la función, esta alteración será reconocida en todo el ámbito de definición del arreglo.

#include <stdio.h>
#include <conio.h>

int sumar( int m[ ] )

{
int suma, i;

suma = 0;
for( i=0; i<10; i++ )
 {
suma += m[i];
}
return suma;
}

main()
{
int contador;
int matriz[10] = { 10, 11, 13, 10, 14, 9, 10, 18, 10, 10 };

for( contador=0; contador<10; contador++ )

printf( " %3i\n", matriz[contador] );
printf( "+ -----\n" );
printf( " %3d", sumar( matriz ) );
getch();
}

Este programa tiene alguna cosita adicional como que muestra toda la matriz en una
columna. Además se usa para imprimir los números %3d. El 3 indica que se tienen que
alinear los números a la derecha, así queda más elegante.

Como he indicado no se pasa el arreglo, sino un puntero a ese arreglo.

Otras declaraciones equivalentes serían:

int sumar( int m[] )

ó
int sumar( int m[10] )

En realidad esta última no se suele usar, no es necesario indicar el número de elementos

a la matriz.

int m[] e int *m son equivalentes.