`

Las estructuras de datos es una estructura de datos que puede ser caracterizado por su organizacin y las operaciones que se definen en ella. Los tipos de datos simples que pueden estar organizados en diferentes estructuras de datos: Estticas y dinmicas.

Conjunto de informaciones simples que son tratables como un todo, al mismo tiempo cada uno de sus elementos es identificable por si solo.
ARREGLOS UNIDIMENCIONALES.

ARREGLOS BIDIMENCIONALES.

ARREGLOS MULTIDIMENCIONALES

CADENAS

REGISTROS

Son aquellas en las que el tamao de la memoria se define antes de que el programa se ejecute y no pueda modificarse durante la ejecucin del programa. Estas estructuras estn implementadas en todos los lenguajes. Su principal caracterstica es que ocupan solo una casilla en memoria.

ESTRUCTURAS ESTATICAS EN EL LENGUAJE C.

ARREGLOS UNIDIMENCIONALES. ARREGLOS BIDIMENCIONALES. ARREGLOS MULTIDIMENCIONALES

Conjunto de informaciones simples que son tratables como un todo, al mismo tiempo cada uno de sus elementos es identificable por si solo. Se denominan estticas para distinguirlas de aquellas estructuras de datos o forma de almacenamiento interna que se basan en la utilizacin dinmica de memoria.

Son estructuras de datos cuyo tamao no varia en toda la ejecucin del programa.

Dato estructurado. Es un conjunto de datos del mismo tipo. Este conjunto de variables se almacenan en posiciones consecutivas de memoria.

DATO 1

DATO 2

DATO 3

Unidimensionales (tambin se les conoce con el nombre de vector).

Multidimensionales.
Para visualizar un array de tres dimensiones utilizaramos la imagen de un cubo de elementos, compuesto por varias capas subdivididas a su vez en filas y columnas. Con arrays de ms dimensiones ya no resulta fcil establecer una analoga visual.

Son ejemplos vlidos de declaraciones:

int vector [1200]; /* declara un array llamado vector de 1200 elementos enteros */ char texto [40]; /* declara un array de 40 elementos de tipo carcter */

#define TAM 6 int a[2][3][4][5][TAM]; /* declaracin de un array de cinco dimensiones */

`

Como vemos en este ejemplo, el tamao de una de las dimensiones puede venir determinado tanto por un literal como par un identificador creado con una directiva define, siempre que sea entero. Nunca se podr utilizar para este fin una variable.

Una vez realizada la declaracin, ya podemos referirnos a los valores contenidos en el array simplemente indicando su nombre y, entre corchetes, su ordinal dentro del conjunto. Para el programador, los arrays estarn compuestos por elementos simples y deber preocuparse solo de utilizar un ndice correcto en cada momento, pero no de calcular las posiciones de esos elementos en la memoria principal.

Dependiendo del tipo base, como ya sabemos, los desplazamientos provocados por los ndices utilizados variarn, pero sern calculados por el compilador. Si el tipo de datos es int, para avanzar un elemento probablemente tendr que avanzar dos bytes, pero por ejemplo, el tipo base es una estructura compleja, avanzar un elemento significar para el compilador desplazarse en la memoria quizs a lo largo de cientos de bytes.

Podemos concluir entonces que para el compilador el nombre del array es un puntero constante que se corresponde con la direccin donde empiezan a almacenarse sus elementos y a partir de ella tendr que desplazarse utilizndolos ndices introducidos por el programador. Estos ndices podrn ser tanto una constante como una variable o una expresin de tipo entero.

Habr que tener un especial cuidado en el tratamie nto de los ndices porque algo que no har el compilador es comprobar si se encuentran dentro de los lmites de los arrays.

int vector[5] = {4, 56, 7, 90, 4}; /*vector inicializado como veremos mas adelante */ Printf ("%d\n", vector[ 10]); El compilador realizar el desplazamiento en memoria correspondiente a la ocupacin de diez nmeros enteros, desde la direccin inicial del vector. En esa posicin existir algn valor sin significado para nuestro programa, pero que se presentar en la pantalla.

El lenguaje C permite la inicializacin de arrays en el momento de declararlos. introduciendo en esta declaracin una lista de constantes separadas por comas cuyo tipo sea compatible con el tipo base del array. Ejemplo:
int i[4] = {2, 4, 6, 8};

Los arrays multidimensionales se inicializan exactamente igual que los vectores. Los valores se van introduciendo siguiendo el orden de las dimensiones, por lo que sera recomendable editarlo del modo ms claro posible. Por ejemplo, ser preferible introducir

` ` `

int valores[2][3]={ 5, 9, 32, 27, 6, 81};

` ` `

int valores[2][3]= {{5, 9, 32}, {27, 6, 81}}; que la ms confusa int valores[2][3]={5, 9, 32, 27, 6, 81};

Cuando se inicializa un array de enteros con menos nmeros que los que podra albergar, la mayora de los compiladores rellenarn el espacio restante con ceros As las siguientes inicializaciones serian equivalentes: int enteros[10]={5, 10, 15, 20, 25}; int enteros[10]={5, 10, 15, 20, 25, 0, 0, 0, 0, 0};

` `

En la mayora de las ocasiones, la inicializacin de arrays puede resultar una labor tediosa si el programador tiene que calcular el espacio que necesita para almacenar todos los valores a guardar. Afortunadamente existe la posibilidad de hacer una inicializacin de arrays no delimitados y dejar que sea el compilador el encargado de calcular el espacio necesario para almacenar los valores. Con este tipo de inicializacin el programador se evita la preocupacin de introducir accidentalmente un nmero errneo en la reserva de espacio de memoria para el array.

` ` `

Seria correcta, por tanto, la siguiente declaracin: int c[ ][3] = {10,12,14, 16,18,20} El uso de inicializaciones no delimitadas vale tambin para arrays multidimensionales, aunque en este caso solo es posible dejar sin especificar el tamao de la primera dimensin. Sera necesario conocer aprioris el resto de ndices para poder acceder correctamente a los datos

En el ejemplo anterior, la segunda dimensin debe estar especificada para que el compilador pueda saber que en este caso existen dos filas, cada una de ellas compuesta por tres elementos.

Debemos tener presente que los valores de un array, sea de una o ms dimensiones, se almacenan en la memoria ocupando posiciones consecutivas. El anterior array de dos dimensiones, una tabla, podramos visualizarla como sigue:

El compilador es capaz de distinguir las filas de ese array siempre que se declare el nmero de columnas que contienen.

El caso de los arrays de caracteres en C es un poco especial. A diferencia de otros lenguajes de programacin ste no posee un tipo especfico para tratar las listas de caracteres en las que almacenar informacin alfanumrica. No existe un tipo diferenciado sino que habr que construir cadenas de elementos de tipo char.

Para facilitar el tratamiento de estas listas de caracteres como un todo, bien para saber su longitud, bien para copiarlas o bien para presentarlas en la pantalla, es conveniente introducir en ellas un carcter especial que indique su final. Las funciones que trabajen con ellas podrn recorrerlas hasta el final buscando ese carcter.

Este detalle de funcionamiento es fundamental para los programadores porque cuando reserven la cantidad deposiciones para una cadena de caracteres debern incluir una ms para el carcter nulo '\0', que indica su final.

De esta forma, una inicializacin semeja nte a la que veamos para los nmeros enteros podra ser:
char cadena[14]={ 'P', 'r', 'o', 'g', 'r', 'a', ' m', 'a', ' ', 'e', 'n', ' ', 'C', '\0'};

Queremos almacenar una cadena d e 13 caracteres y por tanto reservamos espacio para 14.

Afortunadamente el compilador de C nos proporciona un cmodo mecanismo para facilitar estas engorrosas inicializaciones

` `

` `

char cadena[17] = "Programando en C"; En este caso, se est utilizando una cadena constante y el propio compilador se encargar de aadirle la terminacin nula, pero seguir siendo responsabilidad del programador reservar espacio suficiente para contenerla. Pero tambin las cadenas de caracteres podrn ser inicializadas sin delimitar, dejando que sea el compilador el que calcule el espacio necesario para almacenar los caracteres y el nulo que marca el fin de la coleccin. unsigned char error[] = "Error en el nmero tecleado"; Con este tipo de inicializacin el programador se evita la preocupaci n de introducir accidentalmente un nmero errneo en la reserva de espacio de memoria para el array.

char cadena[17] = "Programando en C";

En este caso, se est utilizando una cadena constante y el propio compilador se encargar de aadirle la terminacin nula, pero seguir siendo responsabilidad del programador reservar espacio suficiente para contenerla.

Pero tambin las cadenas de caracteres podrn ser inicializadas sin delimitar, dejando que sea el compilador el que calcule el espacio necesario para almacenar los caracteres y el nulo Con que marca el fin de la coleccin.

este tipo de inicializacin el programado r se evita la preocupacin de introducir unsigned char error[] = "Error en el nmero tecleado"; accidentalmente un nmero errneo en la reserva de espacio de memoria para el array.

EJEMPLO }255. /***************************************************************** inverso.c Programa que introduce nmeros reales en un array y los muestra en orden inverso al de lectura. **********************************************************************/ #include <stdio.h> #define N 10 void main(void){ double num[N]; int i; Printf ( \n \n LECTURA DE %d NUMEROS REALES Y PRESENTACION EN ORDEN INVERSO\n\n, N); For (i=0; i<N ;i++){ printf( \nNumero %d: ", i+1); scanf("%lf",&num[1]); } for(i=N-1; i>=0; i--) printf( %.2lf/ ,num[i]); }

` ` `

` ` ` ` ` ` ` ` ` ` ` ` `

` ` ` `

256. /************************************************************* ********* en medio.c Programa que lee nmeros enteros del teclado en un array. La entrada de datos finalizara cuando se introduzca el nmero 0 y el resultado ser el nmero que se encuentra en la mitad de los ledos ( si son dos los que se estn en la mitad. entonces se escribirn ambos nmeros). ************************************************************** **********/

#include <stdio.h> #define TAM 15 void main(void) { int num[TAM], i=0, n; printf("\nLECTURA DE %d NUMEROS ENTEROS COMO MAXIMO Y VISUALIZACION DE LOS CENTRALES",TAM); printf("\nNmero %d (0=fin): ", i+1); scanf("%d",&n); while(n!=0 && i<TAM){ num[i++]=n; if(i==TAM) printf("\n Se ha llenado el array \n"); else{ printf("\nNmero %d (0=fin): ", i+1); scanf("%d",&n); }} IF (i!=0)if(i%2==0) printf("\nElementos centrales: %d y %d\n",num[i/21],num[i/2]); else printf("\nElemento central %d\n",num[i/2]); }

` ` `

` ` ` `

` ` ` ` ` ` `

El lenguaje C no permite pasar como argumento un array completo, es decir, no vamos a tener la posibilidad de pasarlo por valor. Sera necesario entonces pasar como argumento un puntero al array con el que queremos que la funcin trabaje. El lenguaje C nos facilita esta operacin haciendo que la simple invocacin del nombre de un array genere un puntero a su primer elemento.

` `

As, si tenemos unarray de nmeros enteros y un puntero a enteros int enteros[10], *p; las dos siguientes sentencias sern equivalentes:
p=&enteros[0]; p=enteros;

Naturalmente, sta ltima ser preferible porque contribuye a obtener un cdigo ms legible. Podramos ya llamar a una funcin envindole como argumento un puntero al array, de cualquiera de estas dos formas: funcin(&enteros[0]); funcin(enteros);

` `

Vemos a continuacin un sencillo ejemplo en el que se trabaja con unarray denmeros enteros que es enviado come argumento a dos funciones, una que leintroduce valores y otra que los presenta en pantalla.

pasoarra.c Programa que prueba el paso de arrays entre funciones. ****************************************************** ****************/ #include <stdio.h> #define MAX 10 void introducir_valores(int valores[ ]); void ver_valores(int valores[ ]); void main(void) { int valores [MAX]; printf("\n\nPRUEBA DEL PASO DE ARRAYS ENTRE FUNCIONES\n\n"); printf("Introduzca un mximo de %d nmeros naturales (<0 para acabar)\n", MAX); introducir_valores(valores); printf("Los valores introducidos fueron:\n"); ver_valores(valores); }

` ` ` ` ` `

` `

}/*************************************************************** ******* void introducir_valores(int *valores) Funcin que recibe un puntero al array de enteros y modifica sus valores. **************************************************************** ******/ void introducir_valores(int *valores) { int i=-1; do { i++; printf("Valor natural %d: ", i); scanf("%d", &valores[i]); } while (i<MAX-1 && valores[i]>=0); } void ver_valores(int valores[ ]) Funcin que recibe un puntero al array de enteros y presenta en pantalla sus valores. **************************************************************** ******/ void ver_valores(int valores[ ]) { int i=0; while(i<MAX && valores[i]>=0) { printf("Valor natural %d: %d\n", i, valores[i]); i++; }

` ` `

` ` ` ` ` `

` ` `

` ` ` ` `

Vemos en este ejemplo cmo las funciones reciben un puntero al vector y trabajan despus directamente con sus valores, incluso modificndolos. Cuando se hace la definicin formal de las funciones que recibirn ese puntero. Existen tres posibilidades para escribir el parmetro formal:
Un array delimitado. Un puntero Un array no delimitado.
x En el ejemploanterior serian equivalentes

` ` `

void introducir_valores (int valores[MAX]) void introducir_valores (int *valores) void introducir _valores (int valores[])

De hecho, e insistiendo en la idea de que el compilador de C no comprobara los lmites de los arrays, podramos escribir la siguiente sentencia y el programa seguira funcionando correctamente:
void introducir_valores(int valores[5000])

Solo estamos informando a la funcin de que va a recibir un puntero a un entero; el saber que se trata de un vector y el controlar sus lmites sern tareas del programador

Ahora podemos ver claramente cual es la relacin directa que existe entre la aritmtica de punteros y la utilizacin de vectores. Cuando en un programa nos referimos a un determinado elemento de un vector, el compilador deber sumar el valor del ndice del elemento al puntero de inicio del vector, para desplazarse as hasta el elemento que se quiere utilizar:

valores[3]=2; /* es lo mismo que *(valores+3)=2; */

Cuando lo que se utiliza coma argumento de una funcin es un array multidimensional, ser necesario que el parmetro formal proporcione al compilador el tamao de todas las dimensiones exceptuando, como mximo, la primera. En realidad, estaremos pasando igual que antes un puntero al primer elemento, pero el compilador necesitar esa informacin para poder desplazarse par un conjunto de valores que residen contiguos en la memoria principal.