ARREGLOS

Los arreglos unidimensionales son secuencias de valores del mismo tipo que se almacenan en localidades contiguas de memoria, segn el orden del ndice. <tipo dato> esp <identificador>[tamao];

Ejemplo:
int valores[10]; float datos[5]={1.3,2.8,4.89,0.0,5.7};

char pais[]=MXICO;
char *nombre=VLADIMIR;

La declaracin de un arreglo unidimensional consiste en establecer las caractersticas del arreglo

y sus elementos, por medio de la siguiente sintaxis: <tipo> [ ] < identificador > ; Donde:

tipo indica el tipo correspondiente a los elementos del arreglo, identificador es el nombre del
arreglo, y el par de corchetes, [ ], representa la dimensin del arreglo y encierra un nmero entero que corresponde al nmero de elementos del arreglo. Ejemplos:

int [ ] a ;
float [ ] distancia ; Artculo [ ] art = new Artculo[ 3];
Observe que, en la declaracin, el espacio entre los corchetes est vaco. Esto se debe a que, durante dicha operacin, no se reserva espacio en la memoria.

 Los ndices son necesarios para desplazarse a travs del arreglo. El primer elemento tiene el ndice cero y el ltimo el ndice (tamao-1). Se deben utilizar variables enteras y para agilizar el acceso a memoria se pueden declarar con el modificador register. Ejemplo:

int register i, j, k;

 Un arreglo puede tener N dimensiones, dependiendo de las limitaciones de la memoria y su declaracin es la siguiente: <tipo dato> esp <identificador>[dim1] [dim2][dimN];

Ejemplo:
double cubo[3][3][3];

consiste en reservar espacio de memoria para todos sus elementos, utilizando la siguiente sintaxis: < identificador > = new <tipo> [ tamao ] ; Donde: new es el operador para gestionar espacio de memoria, en tiempo de ejecucin, tamao es un nmero entero que representa el nmero de elementos del arreglo. Ejemplos: a = new int [10] ; distancia = new float[ 5] ; // Se crea el arreglo a , con 10 elementos de tipo entero. // Se crea el arreglo distancia , con 5 elementos de punto flotante y precisin sencilla .Artculo [] art = new Artculo[3]; Artculo [ ] art = new Artculo[ 3]; art[0]= new Artculo(); art[1]= new Artculo(); art[2]= new Artculo(); // Se crean 3 referencias a objetos de la clase Artculo // Se crea el primer objeto del arreglo art // Se crea el segundo objeto del arreglo art // Se crea el tercer objeto del arreglo art

Las dos primeras operaciones de declaracin y creacin anteriores se pueden agrupar en una sola instruccin, como se muestra enseguida: int [ ] a = new int [10] ; float [ ] distancia = new float[5] ;

Se declara un arreglo de diez elementos, se recorre el arreglo para iniciar todos los elementos en 0, y posteriormente se imprimen los valores de los elementos con su subndice correspondiente. #include <stdio.h> #include <conio.h> main( ) { int n[10], i; for (i=0; i<=9; i++) n[i]=0; printf("%8s%13s\n", "Elemento", "Valor"); for (i=0; i<=9; i++) printf("%8d%13d\n", i, n[i]); getch ( ); return 0; } /* ciclo para mostrar los valores del arreglo */ /*declaracin del arreglo n y la variable entera i */ /* ciclo de inicializacin del arreglo */

Los elementos de un arreglo tambin pueden ser inicializados en la misma declaracin del arreglo, siguiendo al nombre del arreglo con un signo igual y una lista de valores separados por coma y encerrados entre llaves. Si el nmero de valores indicado es menor al nmero de elementos en el arreglo, los elementos restantes se inicializan automticamente en cero. Sin embargo si el nmero de valores inicializadores es mayor al nmero de elementos en el arreglo se genera un error.

El siguiente ejemplo muestra una inicializacin en la declaracin: /* Inicializacion de un arreglo dentro de la declaracion */ #include <stdio.h> #include <conio.h> main( ) { /*declaracion e inicializacion del arreglo n */ int n[10] = {32,27,64,18,95,14,90,70,60,37}; int i; printf("%8s%13s\n", "Elemento", "Valor"); for (i=0; i<=9; i++) /* ciclo para mostrar los valores del arreglo */ printf("%8d%13d\n", i, n[i]); getch ( ); return 0; }

Si de una declaracin con una lista inicializadora se omite el tamao del arreglo, el nmero de elementos en el arreglo ser el nmero de elementos incluidos en la lista inicializadora. Por ejemplo: int n[]={2,4,6,8}; se reserva memoria para 4 elementos del arreglo n (del elemento 0 al 3).

En el ejemplo siguiente la lnea: #define TAMANO 12 define una constante simblica TAMANO cuyo valor es 12. Una constante simblica es un valor que se reemplaza con texto de reemplazo en el preprocesador C, antes de que el programa sea compilado. Cuando el programa es preprocesado, todas las instancias de la constante simblica TAMANO sern remplazadas por el texto de reemplazo 12. Esa es la funcin de la directiva del preprocesador #define.

/* Calcular la suma de los } elementos de un arreglo */ #include (stdio.h) #include (conio.h) #define TAMANO 12 main( ) { int a[TAMANO] = {10,8,7,52,42,27,18,95,14,70,60,37 }, i, total=0; for (i=0; i<=TAMANO -1; i++) /*ciclo para acumulacin de valores*/ total+=a[i]; printf("La suma de los elementos del arreglo es %d\n", total); getch ( ); return 0;

En el siguiente ejemplo se utilizan dos arreglos para la determinacin de frecuencias de respuesta en una encuesta. Tambin se utiliza la directiva del preprocesador #define. /* Programa de frecuencias */ #include (stdio.h) #include (conio.h) #define NUMERO_RESPUESTAS 40 #define NUMERO_FRECUENCIAS 11 main() { int respuesta, numero; int respuestas[NUMERO_RESPUESTAS] = {1,2,5,6,3,4,7,8,10,2,5, 8,10,9,1,4,5,7,5,1,4,5,8,7,8,2,1,8,10,10,10,9,8,5,6,7,5,6,5,6}; int frecuencia[NUMERO_FRECUENCIAS]={0}; /* Inicializacin en cero */ /* Con el siguiente ciclo se recorre el arreglo de respuestas y se incrementa el arreglo de frecuencias en su elemento correspondiente */ for (respuesta=0; respuesta <= NUMERO_RESPUESTAS -1; respuesta++) ++frecuencia[respuestas[respuesta]]; printf("%8s%13s\n", "Nmero", "Frecuencia"); /* Ciclo de impresin de frecuencias */ for (numero=1; numero<=10; numero++) printf("%8d%13d\n", numero, frecuencia[numero]); getch ( ); return 0; }

 Una cadena o String se manipula en lenguaje C, mediante arreglos de caracteres. Los arreglos de caracteres terminan con el carcter nulo \0 que en realidad es el valor cero. La nica diferencia con los arreglos numricos es que se requiere un carcter adicional para indicar cuando el final del arreglo. Ejemplo: char nombre[31]; /* Uso slo 30 */

En C una cadena de caracteres es un arreglo de caracteres individuales. Los arreglos de caracteres tienen varias caractersticas nicas. Un arreglo de caracteres puede ser inicializado utilizando una literal de cadena. Por ejemplo:

char string1[] = primero;

inicializa los elementos de la cadena o arreglo de caracteres string1 a los caracteres individuales de la cadena primero. El tamao del arreglo queda determinado por el compilador, basado en la longitud de la cadena. La cadena primero contiene 7 caracteres ms un caracter especial de terminacin de

cadena, conocido como caracter nulo. Entonces el arreglo string1 contiene 8 elementos. La
representacin del caracter nulo es \0. En C todas las cadenas terminan con este caracter. Un arreglo de caracteres que represente una cadena, debe declararse siempre lo suficientemente grande para contener el nmero de caracteres de la cadena incluyendo el caracter nulo de terminacin.

La declaracin anterior es equivalente a:

char string1*+=,p,r,i,m,e,r,o,\0-;

Dado que la cadena es una arreglo se puede referenciar un caracter en particular utilizando el subndice. Por
ejemplo string1*0+ es p, y string1*4+ es la m.

Se puede leer desde teclado una cadena de caracteres con scanf de la siguiente forma:

char string2[20]; scanf(%s, string2);

/* declaracin del arreglo de 19 caracteres y el nulo */ /*lectura de teclado de una cadena y asignacin a string2 */

en este caso no se utiliza el operador de direccin &, puesto que un arreglo es ya de por s la direccin en

memoria del inicio del arreglo.

La funcin scanf lee caracteres de teclado hasta que se encuentra el primer caracter de espacio en blanco sin importar el tamao. Es posible imprimir una cadena de caracteres con printf de la siguiente forma:

printf(%s, string2);

En el siguiente ejemplo se analiza el manejo de arreglos de tipo char.

/* Manejo de arreglos de tipo char */ #include (stdio.h) #include (conio.h) main( ) { char string1[20], string2[]="Cadena de Caracteres"; int i; printf("Introduzca un string: "); scanf("%s", string1); printf("El string1 es: %s\n",string1); printf("El string2 es: %s\n",string2); printf("El string1 con espacios es: \n"); /* impresion con un espacio despues de cada caracter*/ for (i=0; string1[i] != '\0'; i++) if (string1[i]>='a' && string1[i]<='z') /* si es una letra minuscula hacerla mayuscula */ printf("%c ", string1[i]-32); else /* si no es letra minuscula imprimir tal cual */ printf("%c ", string1[i]); printf("\n"); getch ( ); return 0; }

Para pasar como argumento un arreglo a una funcin, se especifica el nombre del arreglo, sin corchetes, por ejemplo, para pasar a una funcin imprimePresion el arreglo PresionDiaria se realiza de la siguiente manera: imprimePresion(PresionDiaria, 7); en este ejemplo se pasa tambin como parmetro la longitud del arreglo, esto se hace normalmente para que las funciones puedan procesar todos los elementos del arreglo sin tratar de acceder a elementos inexistentes. C pasa de forma automtica los arreglos a las funciones utilizando simulacin de llamadas por referencia, es decir, las funciones llamadas pueden modificar los valores de los elementos en los arreglos originales de los llamadores. Esto se debe a que la funcin llamada no realiza una copia como lo hace con las variables normales, sino que recibe la direccin de memoria del inicio del arreglo, por tanto, donde se hacen las posibles asignaciones dentro de las funciones es en los espacios originales que ocupa el arreglo en memoria. Para que una funcin reciba un arreglo a travs de una llamada de funcin, la lista de parmetros de la funcin debe especificar que se va a recibir un arreglo. Por ejemplo, el encabezado de funcin para la funcin modificarArreglo puede ser escrito como: void modificarArreglo(int b[], int size)

A continuacin se presenta un ejemplo utilizando llamadas a funciones con paso de arreglos como parmetros.

/* Pasando arreglos y elementos individuales de arreglo a funciones */ #include (stdio.h) #include (conio.h) #define SIZE 5 void modificarArreglo( int [], int); /*prototipos de funcion*/ void modificarElemento(int); main( ) { int a[SIZE] = {4,3,2,1,0}; int i; printf("Efecto de pasar un arreglo a una funcion\n"); printf("Los valores originales son:\n"); for (i=0; i<=SIZE-1; i++) printf("%3d", a[i]); printf("\n"); modificarArreglo(a, SIZE); printf("Los valores modificados son:\n"); for (i=0; i<=SIZE-1; i++) printf("%3d", a[i]); printf("\n\nEfecto de pasar un solo elemento por valor\n"); printf("El valor de a[3] es: %d\n", a[3]); modificarElemento(a[3]); printf("El valor de a[3] es: %d\n", a[3]); getch ( ); return 0; }

La mayora de las aplicaciones de cmputo requieren tener datos ordenados En el siguiente ejemplo se realiza uno de los mtodos de ordenacin ms simples conocido como mtodo de burbuja u ordenacin por hundimiento. La tcnica

consiste en llevar a cabo varias pasadas a travs del arreglo, en cada pasada se
comparan pares sucesivos de elementos. Si un par est en orden creciente (o son valores idnticos), los valores se quedan tal como estn. Si un par aparece en orden decreciente sus valores se intercambian de lugar, utilizando una variable que almacenar temporalmente el valor del primer elemento, ste tomar el valor del segundo elemento del par, y por ltimo el segundo tomar el valor temporal que corresponda al primer elemento.

/* Ordenamiento de arreglo por mtodo de burbuja */ #include (stdio.h) #include (conio.h) #define SIZE 10 main( ) { int a[SIZE]= {12,35,6,48,8,27,32,87,52,75}; int i, temporal, ciclo; printf("Los valores en el orden original son: \n"); for (i=0; i<= SIZE -1; i++) printf("%4d", a[i]);

/* Ordenamiento */

for (ciclo=1; ciclo<=SIZE -1; ciclo++) for (i=0; i<=SIZE-1-ciclo; i++) /*Intercambio de valores en caso de no estar en orden */ if (a[i] > a[i+1]) { temporal = a[i]; a[i] = a[i+1]; a[i+1]= temporal; } printf("\nLos valores ordenados son: \n"); /*Impresion de valores ordenados */ for (i=0; i<= SIZE -1; i++) printf("%4d", a[i]); getch ( ); return 0; }

En algunos lenguajes de programacin, y es el caso de C, se permiten arreglos de varios subndices, es decir, arreglos multidimensionales. Generalmente estos arreglos se utilizan para representar tablas de valores con renglones y columnas, donde el primer subndice representa el rengln y el segundo la columna. Para referenciar cualquier elemento del arreglo se deben indicar los dos subndices. Un arreglo de mltiple subndice puede ser inicializado en su declaracin en forma similar a un arreglo de un subndice. Por ejemplo, un arreglo de doble subndice b[2][2] puede ser inicializado con

int b[2][2] = {{ 1, 2}, {3, 4}};

Los valores se agrupan por renglones entre llaves. Por lo tanto, 1 y 2 inicializan b[0][0] y b[0][1], 3 y 4 inicializan b[1][0] y b[1][1]. Si para un rengln dado no se proporcionan suficientes inicializadores, los elementos restantes de dicho rengln se inicializarn a 0. Por ejemplo:

int b[2][2] = {{ 1}, {3, 4}};

inicializara b[0][0] en 1 y b[0][1] en 0, b[1][0] en 3 y b[1][1] en 4.

En la tabla siguiente se muestra la representacin grfica de un arreglo con tres renglones y cuatro columnas.

Rengln0 Rengln1 Rengln2

Columna0 a[0][0] a[1][0] a[2][0]

Columna1 Columna2 Columna 3 a[0][1] a[0][2] a[0][3] a[1][1] a[1][2] a[1][3] a[2][1] a[2][2] a[2][3]

El recorrido de un arreglo de dos dimensiones para impresin o para cualquier

procesamiento deber hacerse con dos ciclos for anidados, de tal modo que el ms exterior recorra todos los renglones, y para cada rengln (el ciclo for interior) recorra todas las columnas del arreglo, de tal forma que cada elemento sea referenciado en los ciclos anidados. A continuacin se muestra un ejemplo simple para impresin de un arreglo bidimensional.

/* Inicializacin de arreglos bidimensionales */ #include (stdio.h) #include (conio.h) void imprimeArreglo(int [][3]); main( ) { int arreglo1[2][3] = { {1,2,3}, {4,5,6}}, arreglo2[2][3] = { 1,2,3,4,5}, arreglo3[2][3] = { {1,2}, {4}}; clrscr(); printf("Los valores en arreglo1 por rengln son: \n"); imprimeArreglo(arreglo1); printf("Los valores en arreglo2 por rengln son: \n"); imprimeArreglo(arreglo2); printf("Los valores en arreglo3 por rengln son: \n"); imprimeArreglo(arreglo3); getch ( ); return 0; } void imprimeArreglo(int arreglo[][3]) { int i,j; for (i=0; i<=1; i++) { for (j=0; j<=2; j++) printf("%5d", arreglo[i][j]); printf("\n"); } }

/* Ejemplo de arreglos bidimensionales */ #include (stdio.h) #include (conio.h) #define ALUMNOS 5 #define EXAMENES 3 int minima(int [][EXAMENES], int, int); int maxima(int [][EXAMENES], int, int); float promedio(int [], int); void imprimeArreglo( int [][EXAMENES], int, int); main( ) { int ialumno, alumCalif[ALUMNOS][EXAMENES] = {{77,74,84},{96,85,96}, {70,69,88},{58,86,90},{75,91,72}}; clrscr(); printf("El arreglo es: \n"); imprimeArreglo(alumCalif, ALUMNOS, EXAMENES); printf("\n\nCalificacin ms baja: %d\n", minima(alumCalif, ALUMNOS,EXAMENES)); printf("Calificacin ms alta: %d\n", maxima(alumCalif, ALUMNOS,EXAMENES)); for (ialumno=0; ialumno<=ALUMNOS - 1; ialumno ++) printf("\nEl promedio para el alumno %d es: %.2f\n", ialumno, promedio(alumCalif[ialumno], EXAMENES)); getch(); return 0; } /*imprime el arreglo */ void imprimeArreglo(int calificaciones[][EXAMENES], int estudiante, int pruebas) { int i,j; printf("\n%-20s%-30s\n"," ", "CALIFICACIONES"); printf("%-20s%6s%6s%6s", "ALUMNO","[0]","[1]","[2]","[3]"); for (i=0; i<= estudiante-1; i++) {

printf("\nAlumno %d ", i); for(j=0; j<=pruebas-1; j++) printf("%6d", calificaciones[i][j]); } }

/*Calificacin mnima */ int minima (int calificaciones[][EXAMENES], int alum, int prueba) { int i, j, minimo = 100; for (i=0;i<=alum-1; i++) for (j=0; j<=prueba-1; j++) if (calificaciones[i][j] < minimo) minimo = calificaciones[i][j]; return minimo; }
/*Calificacin mxima */ int maxima (int calificaciones[][EXAMENES], int alum, int prueba) { int i, j, maximo = 0; for (i=0;i<=alum-1; i++) for (j=0; j<=prueba-1; j++) if (calificaciones[i][j] > maximo) maximo = calificaciones[i][j]; return maximo; } /*Promedio */ float promedio(int calif[], int pruebas) { int i, total=0; for (i=0; i<=pruebas-1; i++) total += calif[i]; return total/pruebas; }

1.

Ingresar 10 conjuntos de 15 nmeros enteros cada uno en un arreglo bidimensional. Guardar cada conjunto en una fila y luego mostrar los datos por filas.

2. 3.

Realizar el ejercicio anterior pero hacerlo por columnas. Ingresar elementos reales en un arreglo bidimensional de 30 filas por 12 columnas. Luego ingresar un dato entero que corresponde al nmero de fila (validar que sea consistente) cuyos elementos se desean sumar. Exhibir dicha suma.

4.

Ingresar 5 conjuntos de 30 nmeros reales cada uno en un arreglo bidimensional. Calcular la suma de sus filas, por otro lado calcular la suma de sus columnas.

5.

Ingresar 20 conjuntos de 20 elementos enteros cada uno en un arreglo bidimensional. Calcular y exhibir la suma de su diagonal principal y de su diagonal secundaria.

6.

Ingresar 10 conjuntos de 12 caracteres cada uno en un arreglo bidimensional. Ingresar luego dos nmeros enteros
correspondientes a los nmeros de dos filas del arreglo, intercambiar sus contenidos y exhibir el arreglo modificado.

7.

Ingresar 5 conjuntos de 5 reales cada uno en un arreglo bidimensional. Ingresar luego dos nmeros enteros correspondientes a una fila y una columna, intercambiar sus contenidos y exhibir el arreglo modificado.

8.

Ingresar nmeros enteros en un arreglo bidimensional A de 10 filas por 5 columnas; luego en otro arreglo B de igual

dimensin, ingresar nmeros enteros. Obtener un arreglo C, siendo C = A + B (cada elemento de C se obtiene como la
suma de los elementos homlogos de A y B. mostrar A, B y C una al lado de la otra. Este es el concepto de suma de matrices.