ARREGLOS

1. Introduccin
Un arreglo es una estructura de datos compuesta por varias variables del mismo tipo agrupadas bajo un nombre comn. Los arreglos permiten agrupar datos usando un mismo identificador. Todos los elementos de un arreglo son del mismo tipo, y para acceder a cada elemento se usan subndices. Un subindice es una constante numrica entera no negativa, o una expresin que evala a una constante numrica entera no negativa colocada entre corchetes a continuacin del nombre del arreglo, y representa la posicin de la variable en el conjunto de variables que forman el arreglo, iniciando desde 0. Esto es, si un arreglo tiene N elementos, el ndice para el mismo podr tomar un valor entre 0 y N-1, donde 0 representa el primer elemento del arreglo, y N-1 representa el ltimo elemento. La sintaxis general para la declaracin de un arreglo es: tipo identificador[nm_elemen1][[<nm_elemen2>]...]; Dependiendo del nmero de veces que aparezca [num_elemen] se determina la dimensin del arreglo. Si aparece una sola vez, se dice que el arreglo es de una dimensin (tambin conocido como lista o vector), si aparece dos veces, el arreglo es de dos dimensiones (tambin conocido como tabla o matriz). Los valores para <num_elemen> deben ser constantes (literales o simblicas), y se pueden usar tantas dimensiones como queramos, limitado slo por la memoria disponible. <num_elemen> representa el nmero de elementos que tiene el arreglo y se dice que es el tamao del arreglo. Para entender esto mejor, se puede decir que un vector entero de tamao [10] est compuesto por 10 variables enteras, pero una matriz entera de tamao [5][10] est compuesta por 5 vectores cada uno de los cuales tiene 10 elementos; o sea, un total de 50 variables enteras. Ahora podemos ver que las cadenas de caracteres son un tipo especial de arreglos. Se trata en realidad de arreglos de una dimensin de variables de tipo char. Para identificar y referenciar cada una de las diferentes variables que conforman un arreglo (los elementos del arreglo) se utilizan subndices. Los subndices son valores enteros encerrados entre corchetes que se colocan a continuacin del nombre del arreglo, y pueden tomar valores desde 0 hasta <nmero_de_elementos>-1. Esto es muy importante, y hay que tener mucho cuidado para no exceder este valor. Por ejemplo, si declaramos el arreglo de una dimensin: int vector[10]; Crear un arreglo con 10 enteros a los que accederemos como vector[0] (que es el primero de los elementos) a vector[9] (que es el ltimo de ellos). Como subndice podremos usar cualquier expresin entera no negativa, esto es, una constante entera no negativa, o una variable entera que contenga un valor entre 0 y <nmero_de_elementos>1 o una expresin que evale a un valor entero entre 0 y <nmero_de_elementos>-1.
1

En general C++ no verifica el mbito de los subndices. Si declaramos un arreglo de 10 elementos, no obtendremos errores al acceder al elemento 11. Sin embargo, si asignamos valores a elementos fuera del mbito declarado, estaremos accediendo a zonas de memoria que pueden pertenecer a otras variables o incluso al cdigo ejecutable de nuestro programa, con consecuencias generalmente desastrosas. Ejemplos: int tabla[5][10]; // declara una matriz de 5*10 enteros char dimensionN[4][15][6][8][11]; // Arreglo de dimensin 5 ... dimensionN[3][11][0][4][6] = dimensionN[0][12][5][3][1]; tabla[0][0] += Tabla[9][9]; tabla[3][7] = 0; Cada elemento del arreglo tabla, desde tabla[0][0] hasta tabla[4][9] es una variable entera. Del mismo modo, cada elemento del arreglo dimensionN es una variable de carcter.

2. Inicializacin de Arreglos
As como se les puede asignar un valor a una variable al momento de declararla, Los arreglos tambin pueden ser inicializados cuando se declaran, asignandole un valor a cada uno de sus elementos. Para esto, a continuacin de la declaracin del arreglo se coloca la lista de los valores para los elementos, encerrados entre llaves, y separados por comas. Ejemplos: 1. 2. 3. 4. 5. 6. int R[4] = {2, 3, 9, 0}; float S[] = {2., 5.3, 0., 3.8, 54., 7.1}; int N[] = {23, 10, 0, 3}; int M[][3] = {2, 1, 5, 12, 4, 0, 2, 3, 7}; char Mensaje[] = "Error de lectura"; char Saludo[] = {'H', 'o', 'l', 'a', 0};

En estos casos no es obligatorio especificar el tamao para la primera dimensin, como ocurre en los ejemplos de las lneas 2, 3, 4, 5 y 6. En estos casos la dimensin que queda indefinida se calcula a partir del nmero de elementos en la lista de valores iniciales. En el caso 2, el nmero de elementos es 6, ya que hay seis valores en la lista. En el caso 3, ser 4. En el caso 4, ser 3, ya que hay 9 valores, y la segunda dimensin es 3: 9/3=3. En el caso 5, el nmero de elementos es 17, 16 caracteres ms el cero de fin de cadena. Por otra parte, se puede asignar valores implcitamente, omitiendo algunos de ellos, as, por ejemplo, int datos[6] = {0}; float saldo[5]={2., 5.4};

En estos casos, la inicializacin procede a partir del primer elemento, y los elementos faltantes se inicializan en cero. As, todos los elementos de datos quedan en 0, y los elementos 2, 3, y 4 de saldo quedan en 0. Otra forma de inicializar arreglos es mediante el uso de un ciclo for que recorre todos sus elementos asignndoles un valor a cada uno de ellos. Por ejemplo: int datos[15]; // arreglo de 15 valores enteros int i; // variable de control del ciclo for . . . for(i=0;i<15;i++) datos[i] = 0; Recorre el arreglo datos desde la posicin 0 (primer elemento) hasta la posicin 14 (ltimo elemento) y le asigna el valor cero a cada uno de ellos. Si se tratara de un arreglo bidimensional, se requeriran dos ciclos: Uno externo para recorrer las filas y otro interno para recorrer las columnas, as: int ventas[12][4]; // arreglo de 12 filas y 4 columnas int i, j; // variables de control para los ciclos . . . for(i=0;i<12;i++) // ciclo for externo, para las filas for(j=0;j<4;j++) // ciclo for interno, para las columnas datos[i][j] = 0; // coloca en cero el elemento i,j El arreglo ventas tiene 12 filas y 4 columnas (matriz de 12x4). El ciclo for externo recorre las filas, desde la fila 0 hasta la fila 11, y para cada fila, el ciclo for interno recorre las columnas, desde la columna 0 hasta la columna 3. De esta manera, cada elemento i,j del arreglo queda con el valor 0. Una tercera opcin para inicializar un arreglo es leyendo sus datos desde el teclado, mediante el uso de operaciones de entrada de datos, as, por ejemplo: int datos[15]; // arreglo de 15 valores enteros int i; // variable de control del ciclo for . . . for(i=0;i<15;i++) { cout<<Digite el valor del elemento <<(i+1); cin>>datos[i]; } En este caso, el ciclo for repetira 15 veces la solicitud del dato y la lectura correspondiente. Nota: Observe que en la solicitud se ajusta el valor de modo que para la primera iteracin, cuando i vale 0, se tendra: Digite el valor del elemento 1

3. Operaciones con Elementos de Arreglos

3

No es posible hacer operaciones utilizando arreglos completos. En su lugar, hay que utilizar los elementos individuales del arreglo, especificando el nombre del arreglo y el ndice de cada elemento (recordemos que comienzan en 0). As, por ejemplo: 1. 2. 3. 4. 5. ventas[mes] += cven; pasajero[estacion] = pasajero[estacion]+1; cuenta[5]++; saltot = saltot + saldo[i]; deuda[4] = deuda[0]+deuda[1]+deuda[2]+deuda[3];

En la lnea 1, se acumula el valor contenido en la variable cven al elemento numero mes del arreglo ventas. mes debe ser un entero. En la lnea 2, se incrementa en 1 el valor contenido en el elemento nmero estacion del arreglo pasajero. estacion debe ser un entero. En la lnea 3, se incrementa en 1 el valor contenido en el elemento nmero 5 (sexta posicin) del arreglo cuenta. En la lnea 4, se adiciona a saltot el valor contenido en el elemento i del arreglo saldo. i debe ser un entero. En la lnea 5, se guarda en el quinto elemento del arreglo deuda la suma de los valores de los 4 primeros elementos. No debemos olvidar que el ndice del arreglo debe ser siempre un valor entero, y debe estr dentro del mbito del arreglo. As, si un arreglo se define con dimensin 5, sus ndices solo pueden valer 0, 1, 2, 3, o 4. Si se referencia un ndice diferente, posiblemente el compilador no lo detecte pero vamos a incurrir en un error grave que surge al momento de ejecutar el programa.

4. Operaciones Comunes Sobre Arreglos

Veamos a continuacin algunas de las operaciones que se pueden hacer con arreglos: 4.1. Obtener el mayor valor de un arreglo

Cuando deseamos obtener el valor mayor de todos los valores definidos en un arreglo de tamao n, debemos recorrer todo el arreglo y utilizar una variable que nos ayude en esta comparacin. La mejor manera de inicializar esta variable es utilizar el primer valor del arreglo, por ejemplo:
int mayor = arreglo[0]; int i; // se toma el primer valor como el mayor

// se revisa cada elemento en el arreglo empezando por el segundo for (i=1; i < n; i++) { // si el elemento del arreglo es mayor, cambiamos el valor del mayor if (arreglo[i] > mayor) mayor = arreglo[i]; } cout<<El valor mayor es <<mayor;

4.2.

Obtener el ndice en el que se encuentra el mayor valor

4

Para hacer esto definimos otra variable, la cual debe empezar con 1 y si el valor del arreglo es mayor, adems de hacer el cambio de mayor, actualizamos la posicin de donde se encontr el mayor, el ejemplo quedara como:
int posicin = 0; int i; int mayor = arreglo[0];

// se toma el primer valor como el mayor

// se revisa cada elemento en el arreglo desde el segundo for (i=1; i < n; i++){ if (arreglo[i] > mayor){ // si el elemento del arreglo es mayor mayor = arreglo[i]; // cambiamos el valor del mayor posicion = i; // se actualiza la posicion } } cout<<El valor mayor es <<mayor<<endl; cout<<Y esta en la posicion <<(posicin+1);

Si queremos saber en qu posicin se encontr el mayor valor, entonces debemos utilizar un ndice, el cual empieza en 0 (si es que tomamos como referencia inicial el primer valor) y despus al detectar que el valor del arreglo es mayor, se hace el cambio con mayor y se actualiza la posicin, al desplegar la posicin le aadimos uno ms, ya que empieza desde cero. 4.3. Obtener el menor valor de un arreglo y su posicin

Para obtener el valor menor, solo se cambia la comparacin y en lugar de comparar por mayor, se compara por menor, el ejemplo lo vemos como sigue:
int posicin = 0; int i; int menor = arreglo[0];

// se toma el primer valor como el menor

// se revisa cada elemento en el arreglo desde el segundo for (i=1; i < n; i++){ if (arreglo[i] < menor){ // si el elemento del arreglo es menor menor = arreglo[i]; // cambiamos el valor del menor posicion = i; // se actualiza la posicion } } cout<<El valor menor es <<menor<<endl; cout<<Y esta en la posicion <<posicion;

4.4.

Obtener el promedio de un arreglo

Para obtener el promedio de un arreglo de tamao n, se debe hacer la sumatoria de los elementos y dividir esta sumatoria entre el nmero de elementos del arreglo. El ejemplo lo vemos como sigue:
float promedio; int i; 5

float suma = 0;

// se inicializa la suma en cero

// se hace la sumatoria de los elementos del arrreglo for (i=0; i < n; i++) suma += arreglo[i]; promedio = suma / n; cout<<El promedio es <<promedio;

4.5.

Buscar un valor en un arreglo

Para buscar un valor en un arreglo, se debe recorrer el arreglo comparando cada elemento del mismo con el valor a buscar, y al encontrarlo se guarda la posicin y se termina la bsqueda. El ejemplo lo vemos como sigue:
int i; int posicion = -1; int valor;

// valor a buscar

// Se lee el valor a buscar cout<<Digite el valor a buscar: ; cin>>valor; // se hace el recorrido de los elementos del arrreglo buscando el valor for(int i=0; i < n; i++){ if(arreglo[i] == valor){ // encuentra el valor posicion = i; // guarda la posicion break; // termina el ciclo for } } if(posicion == -1) cout<<\nEl valor <<valor<< no esta en el arreglo; else cout<<\nEl valor <<valor<< esta en el arreglo, en la posicin <<(posicion+1);

4.6.

Ejemplo

A continuacin se presenta un programa que utiliza todos estos conceptos para su visualizacin:
#include <iostream> using namespace std; #define MAX 10 int main() { // se define el arreglo a utilizar int arreglo[] = {12, 75, -5, 99, 124, 8, -45, 12, 25, 0}; int posicion; // para las posiciones int mayor, menor; // para el mayor y el menor float promedio; // para obtener el promedio int suma = 0; // se inicializa la suma en cero

// Mostrar los valores en pantalla for (int i=0; i < MAX; i++) { cout<<"Elemento "<<(i+1)<<" = "<<arreglo[i]<<endl; } // determinar el mayor valor y su posicin mayor = arreglo[0]; // se toma el primer valor como el mayor posicion = 0; // para definir mayor en la primera posicin // se revisa cada elemento en el arreglo desde el segundo for (int i=1; i < MAX; i++) { if (arreglo[i] > mayor) // si el elemento del arreglo es mayor { mayor = arreglo[i]; // cambiamos el valor del mayor posicion = i; // se actualiza la posicion } } cout<<"El valor mayor es "<<mayor<<endl; cout<<"Y esta en la posicion "<<(posicion + 1)<<endl; // determinar el menor valor y su posicin menor = arreglo[0]; // se toma el primer valor como el menor posicion = 0; // para definir menor en la primera posicin // se revisa cada elemento en el arreglo desde el segundo for (int i=1; i < MAX; i++) { if (arreglo[i] < menor) // si el elemento del arreglo es menor { menor = arreglo[i]; // cambiamos el valor del menor posicion = i; // se actualiza la posicion } } cout<<El valor menor es "<<menor<<endl; cout<<"Y esta en la posicion "<<(posicion+1)<<endl; // obtener el promedio de los valores en el arreglo for (int i=0; i < MAX; i++) // se tomara cada elemento para sumarlo { suma += arreglo[i]; } promedio = suma / MAX; cout<<"El promedio de los valores en el arreglo es "<<promedio; cout<<\n\n; system(pause);

5. Operadores con Arreglos

Ya hemos visto que se puede usar el operador de asignacin al declarar un para asignar valores iniciales a sus elementos. El otro operador que tiene sentido con los arreglos es sizeof. Aplicado a un arreglo, este operador devuelve el tamao de todo el arreglo en bytes. Podemos obtener el nmero de elementos dividiendo ese valor entre el tamao de uno de los elementos. Por ejemplo.
7

#include <iostream> using namespace std; int main() { int arreglo[231]; cout << "Nmero de elementos: "<< sizeof(arreglo)/sizeof(int)<<endl; cout << "Nmero de elementos: "<<sizeof(arreglo)/sizeof(arreglo[0])<<endl; }

Las dos formas son vlidas, pero la segunda es, tal vez, ms general.

6. La Ordenacin de Arreglos
Una operacin que se hace muy a menudo con los arreglos, sobre todo con los de una dimensin, es ordenar sus elementos, que consiste en colocarlos de modo que queden en un orden dado (ascendente o descendente), si el arreglo es numrico, o en orden alfabtico o alfanumrico cuando se trata de caracteres o cadenas de caracteres. Cuando un arreglo est ordenado, se facilitan algunas operaciones como la bsqueda de un elemento. Existen varios algoritmos para ordenar arreglos unidimensionales. Aqu veremos algunos de ellos. Mtodo de la burbuja Este es uno de los algortmos ms usados, aunque no es muy eficiente. Este mtodo consiste en recorrer la lista de valores a ordenar y compararlos dos a dos. Si los elementos estn bien ordenados, pasamos al siguiente par, si no lo estn los intercambiamos, y pasamos al siguiente, hasta llegar al final de la lista. El proceso completo se repite hasta que la lista est ordenada. Lo veremos mejor con un ejemplo: Ordenar la siguiente lista de menor a mayor: 15, 3, 8, 6, 18, 1. Empezamos comparando 15 y 3. Como estn mal ordenados los intercambiamos, la lista quedar: 3, 15, 8, 6, 18, 1 Tomamos el siguiente par de valores: 15 y 8, y volvemos a intercambiarlos, y seguimos el proceso... Cuando lleguemos al final la lista estar as: 3, 8, 6, 15, 1, 18 Empezamos la segunda pasada, pero ahora no es necesario recorrer toda la lista. Si observas vers que el ltimo elemento est bien ordenado, siempre ser el mayor, por lo tanto no ser necesario incluirlo en la segunda pasada. Despus de la segunda pasada la lista quedar: 3, 6, 8, 1, 15, 18 Ahora es el 15 el que ocupa su posicin final, la penltima, por lo tanto no ser necesario que entre en las comparaciones para la siguiente pasada. Las sucesivas pasadas dejarn la lista as: 3 pasada: 3, 6, 1, 8, 15, 18
8

4 pasada: 5 pasada:

3, 1, 6, 8, 15, 18 1, 3, 6, 8, 15, 18

El cdigo a continuacin muestra un programa que lee un conjunto de datos y los almacna en un arreglo. Despues ordena el arreglo de menor a mayor utilizando el mtodo de la burbuja, y lo muestra en la pantalla.
/************************************************************************* Programa: burbuja Objetivo: Lee un conjunto de nmeros y los muestra ordenados de menor A mayor Autor: El profesor **************************************************************************/ #include <iostream> using namespace std; #define TAM 10 int main() { int A[TAM]; // arreglo de nmeros enteros int temp, j, i; // variable auxiliar e ndices para ciclos for // lectura de datos for(i=0;i<TAM;i++){ cout<<"\nDigite el valor numero "<<(i+1)<<": "; cin>>A[i]; } // ordena el arreglo de numeros for(i = (TAM-1); i >= 0; i--) { for(j = 1; j <= i; j++) { if(A[j-1] > A[j]) // Intercambio de numeros { temp = A[j-1]; A[j-1] = A[j]; A[j] = temp; } } } // Muestra la lista de numeros ordenados cout<<"\n\nLista de numeros ordenada:\n"; for(i=0;i<TAM;i++) cout<<A[i]<<","; cout<<"\n\n"; system("pause");

Mtodo de seleccin Este algoritmo consiste en comparar el primer elemento del arreglo con cada uno de los demas y cada vez que se encuentre un valor menor, se intercambia con el primero. Luego se repite la operacin con el segundo elemento y as sucesivamente. Su funcionamiento detallado es el siguiente:
9

Buscar el mnimo elemento de la lsta Intercambiarlo con el primero Buscar el mnimo en el resto de la lista Intercambiarlo con el segundo

Y en general:

Buscar el mnimo elemento entre una posicin i y el final de la lista Intercambiar el mnimo con el elemento de la posicin i

Veamos el mismo ejemplo: Ordenar la siguiente lista de menor a mayor: 15, 3, 8, 6, 18, 1. Empezamos comparando el primer elemento con cada uno de los elementos subsiguientes, y cada vez que encontremoa un valor menor que el primero los intercambiamos. As, se compara el valor 15 con 3 (intercambio), luego 3 (que ahora es el primer elemento) con 8, 3 con 6, 3 con 18, y 3 con 1 (intercambio). En este punto, la lista est as: 1, 15, 8, 6, 18, 3, y el primer elemento de la lista es el menor de todos. En la segunda pasada se compara el segundo elemento con cada uno de los dems, intercambiando cada vez que se encuentre un valor menor al segundo. As, se compara 15 con 8 (intercambio), luego 8 con 6 (intercambio), despus 6 con 18, y por ltimo 6 con 3 (intercambio). En este punto, la lista est as: 1, 3, 15, 8, 18, 6. Las sucesivas pasadas dejarn la lista as: 3 pasada: 4 pasada: 5 pasada: 1, 3, 6, 15, 18, 8 1, 3, 6, 8, 18, 15 1, 3, 6, 8, 15, 18

El cdigo a continuacin muestra un programa que lee un conjunto de datos y los almacna en un arreglo. Despues ordena el arreglo de menor a mayor utilizando el mtodo de seleccin, y lo muestra en la pantalla.
/************************************************************************* Programa: seleccion Objetivo: Lee un conjunto de nmeros y los muestra ordenados de menor A mayor usando el mtodo de seleccin Autor: El profesor **************************************************************************/ #include <iostream> using namespace std; #define TAM 10 int main() { int A[TAM]; // arreglo de nmeros enteros int temp, j, i; // variable auxiliar e ndices para ciclos for // lectura de datos for(i=0;i<TAM;i++){ cout<<"\nDigite el valor numero "<<(i+1)<<": ";

10

cin>>A[i];

// ordena el arreglo de nmeros usando el mtodo de seleccion for(i = 0; i < (TAM-1); i++) { for(j = (i+1); j <TAM; j++) { if(A[j] < A[i]) // Intercambio de numeros { temp = A[i]; A[i] = A[j]; A[j] = temp; } } } // Muestra la lista de numeros ordenados cout<<"\n\nLista de numeros ordenada:\n"; for(i=0;i<TAM;i++) cout<<A[i]<<","; cout<<"\n\n"; system("pause");

6.1.Arreglos Dinmicos
Como hemos visto los arreglos son una herramienta muy potente y sencilla de implementar aunque tienen un lado negativo: su tamao. El tamao de un arreglo debe especificarse al momento de su declaracin. De esta manera separa un bloque de memoria para su uso; sin embargo, hay situaciones en que sera preferible poder especificar de manera dinmica el tamao del arreglo, sea porque el numero de elementos del mismo puede variar en cada ejecucin del programa o sea porque no sabemos exactamente que tamao tendr el arreglo. En esta situacin es donde aparecen los arreglos dinmicos, que son arreglos a los que se puede especificar su tamao durante la ejecucin del programa, mediante una variable, determinando as dinmicamente el tamao del arreglo. De esta manera se reserva solo la cantidad de memoria que se requiere para el arreglo. Para definir arreglos dinmicos, se requiere utilizar variables puntero (tema que se tratar mas adelante, pero que trabajaremos aqu a modo sintactico). A continuacin se ilustra un trozo de cdigo en el que se crea un arreglo dinmico de una dimensin (vector):
int n; cout<<Digite el tamao del arreglo: ; cin>>n; int *A = new int[n]; // creacion del arreglo dinamico A

De esta manera se ha creado el arreglo A, con exactamente n elementos. Ahora para usar este arreglo lo hacemos como lo haciamos con los arreglos estaticos, es decir: i=0;
11

A[i]=9; Sin embargo, cuando se crea un arreglo dinmico, este se debe eliminar antes de terminar la ejecucin del programa, ya que si no se hace, esos espacios de memoria permanecen reservados. Para eliminar un arreglo dinmico usamos la funcin delete:
delete(A);

A continuacin se ilustra con un ejemplo el uso de un arreglo dinmico de una dimensin:

#include <iostream> using namespace std; int main() { int n; cout<<"Digite el tamao del arreglo: "; cin>>n; int *A = new int[n]; // creacion del arreglo dinamico for(int i=0; i<n; i++){ cout<<"\nValor numero "<<(i+1)<<":"; cin>>A[i]; } cout<<"\n\nValores digitados: "; for(int i=0; i<n; i++) cout<<A[i]<<","; delete(A); // elimina el arreglo cout<<"\n\nDespues del delete: "; for(int i=0; i<n; i++) cout<<A[i]<<","; cout<<"\n\nFin del programa\n\n"; system(pause); }

Se pueden crear arreglos dinmicos de dos dimensiones de una manera similar. Por ejemplo, para crear un arreglo dinmico de dos dimensiones n por m, se escribira:
int n, m; // filas y columnas que tendra el arreglo cout<<Digite el numero de filas y el numero de columnas del arreglo: ; cin>>n>>m; int **A = new int *[m]; // crea un vector con m punteros a entero for(int i=0; i<m; i++){ // crea m vectores de enteros de tamao n A[i] = new int[n]; }

Como se dijo al comienzo, este tema quedar ms claro cuando se trabaje el tema de punteros.

12