2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 4 - Arrays Índice del Capítulo 4.1Introducción 4.2Arrays 4.3Declaración de Arrays 4.4Ejemplos

2003 Prentice Hall, Inc. All rights reserved.

1

Capítulo 4 - Arrays

Índice del Capítulo4.1 Introducción4.2 Arrays4.3 Declaración de Arrays4.4 Ejemplos de uso de Arrays4.5 Paso de Arrays a Funciones4.6 Ordenación de Arrays4.7 Ejemplo: Cálculo de Media, Mediana y Moda usando Arrays4.8 Búsqueda en Arrays: Búsqueda Lineal y Búsqueda Binaria4.9 Arrays Multidimensionales


2

4.1 Introducción

• Arrays– Estructuras de datos consistente en elementos de datos

relacionados del mismo tipo.

– Entidad estática (mismo tamaño durante toda la ejecución del programa)

• Tipos – Basados en punteros (tipo C)

– Arrays como objetos (C++)


3

4.2 Arrays

• Array– Grupo de localizaciones consecutivas de memoria

– Mismo nombre y tipo (int, char, etc.)

• Para hacer referencia a un elemento:– Especificamos nombre del array y número de posición

(índice)

– Formato: nombrearray[ número_posición ]

– El primer elemento está en la posición 0

• Array c de n elementos:c[ 0 ], c[ 1 ] … c[ n - 1 ]

– Elemento n-ésimo en la posición n-1


4

4.2 Arrays

• Los elementos de un array son como otras variables– Asignación, impresión de un array de enteros c

c[ 0 ] = 3;

cout << c[ 0 ];

• Número de posición=índice.– Índice= entero o expresión entera

– Se pueden realizar operaciones sobre el índicec[ 5 – 2 ] es lo mismo que c[3]


5

4.2 Arrays

c[6]

-45

6

0

72

1543

-89

0

62

-3

1

6453

78

Nombre del array (Notad que todos los elementos de este array tienen el mismo nombre, c)

c[0]

c[1]

c[2]

c[3]

c[11]

c[10]

c[9]

c[8]

c[7]

c[5]

c[4]

Número de posición del elemento dentro de array c

Imprimo la suma de los 3 primeros elementos del array:

cout << c[0] + c[1] + c[2] << endl;

Divido el valor del 7º elemento por 2 y lo asigno a la variable x:

x = c[6] / 2;


6

4.3 Declaración de Arrays

• Cuando se declaran arrays, hay que especificar:– Nombre

– Tipo del array• Cualquier tipo de datos

– Número de elementos

– tipo nombreArray[ tamañoArray ];int c[ 10 ]; // array de 10 enteros

float d[ 3284 ]; // array de 3284 floats

• Declaración de varios arrays del mismo tipo:– Lista separada por comas, como las variables

int b[ 100 ], x[ 27 ];


7

4.4 Ejemplos de Uso de Arrays

• Inicialización de arrays – Lazo for

• Dar un valor inicial a cada elemento dentro de un lazo

– Lista de inicialización• Se especifica cada valor al declarar el array

int n[ 5 ] = { 1, 2, 3, 4, 5 }; • Si no hay suficientes valores iniciales, los más a la derecha se

fijan a 0• Si hay demasiados valores iniciales: error de sintaxis

– Para fijar todos los elementos al mismo valorint n[ 5 ] = { 0 };

– Si se omite el tamaño del array, la lista de valores iniciales determina su tamaño

int n[] = { 1, 2, 3, 4, 5 }; • 5 valores iniciales, por tanto array de 5 elementos

2003 Prentice Hall, Inc.All rights reserved.

Outline8

1 // Fig. 4.3: fig04_03.cpp2 // Declaración de array e Inicialización de elementos usando lazo for.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 int main()13 {14 int n[ 10 ]; // n es un array de 10 enteros15 16 // inicializo los elementos del array n a 017 for ( int i = 0; i < 10; i++ ) 18 n[ i ] = 0; // fijo el elemento en la localización i a 019 20 cout << "Elemento" << setw( 13 ) << "Valor" << endl;21 22 // imprimo contenidos de array n en formato tabular23 for ( int j = 0; j < 10; j++ ) 24 cout << setw( 7 ) << j << setw( 13 ) << n[ j ] << endl;25 26 return 0; 27 28 }

Declaración de un array de 10 elementos enteros.

Inicialización del array a 0 usando un lazo for. Nótese que el array tiene los elementos de n[0] a n[9].


Outline9

Elemento Valor

0 0

1 0

2 0

3 0

4 0

5 0

6 0

7 0

8 0

9 0


Outline10

1 // Fig. 4.4: fig04_04.cpp2 // Inicialización del array en la declaración mediante lista de valores iniciales.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 int main()13 {14 // uso lista de valores iniciales para inicializar array n15 int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };16 17 cout << "Elemento" << setw( 13 ) << "Valor" << endl;18 19 // output contents of array n in tabular format20 for ( int i = 0; i < 10; i++ )21 cout << setw( 7 ) << i << setw( 13 ) << n[ i ] << endl;22 23 return 0; 24 25 }

Nótese el uso de la lista de valores iniciales.


Outline11

Elemento Valor

0 32

1 27

2 64

3 18

4 95

5 14

6 90

7 70

8 60

9 37


12

4.4 Ejemplos de uso de Arrays

• Especificación del tamaño del array mediante una constante– Puede especificarse mediante una ¿variable constante?

(const)• const int size = 20;

– Las constantes no pueden modificarse

– Las constantes deben inicializarse al declararlas

– También llamadas constantes con nombre o variables de sólo lectura


Outline13

1 // Fig. 4.5: fig04_05.cpp2 // Especificación tamaño array con constante. Inicialización con cálculos.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 int main()13 {14 // constante que especifica el tamaño del array15 const int arraySize = 10;16 17 int s[ arraySize ]; // el array s tiene 10 elementos18 19 for ( int i = 0; i < arraySize; i++ ) // fijo los valores20 s[ i ] = 2 + 2 * i; 21 22 cout << "Elemento" << setw( 13 ) << "Valor" << endl;23 24 // salida de contenido del array s en formato tabular25 for ( int j = 0; j < arraySize; j++ ) 26 cout << setw( 7 ) << j << setw( 13 ) << s[ j ] << endl;27 28 return 0;29 30 }

Nótese el uso de la palabra clave const. Sólo las variables const pueden especificar tamaños de arrays.

El programa se vuelve más escalable cuando fijamos el tamaño del array usando una variable const. Podemos cambiar arraySize, y todos los lazos seguirán funcionando (de otro modo, tendríamos que actualizar cada lazo del programa).


Outline14

Elemento Valor

0 2

1 4

2 6

3 8

4 10

5 12

6 14

7 16

8 18

9 20


Outline15

1 // Fig. 4.6: fig04_06.cpp2 // Uso de una variable constante correctamente inicializada.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 int main()9 {10 const int x = 7; // variable constante inicializada11 12 cout << "El valor de la variable constante x es: "13 << x << endl;14 15 return 0;16 17 }

El valor de la variable constante x es: 7

Inicialización correcta de la variable const.


Outline16

1 // Fig. 4.7: fig04_07.cpp2 // Un objeto constante debe inicializarse.3 4 int main()5 {6 const int x; // Error: x debe inicializarse7 8 x = 7; // Error: no se puede modificar una variable constante9 10 return 0; 11 12 }

d:\cpphtp4_examples\ch04\Fig04_07.cpp(6) : error C2734: 'x' : const object must be initialized if not extern

d:\cpphtp4_examples\ch04\Fig04_07.cpp(8) : error C2166:

l-value specifies const object

const no inicializada causa un error de sintaxis. Intentar modificar la const es otro error.


Outline17

1 // Fig. 4.8: fig04_08.cpp2 // Cálculo de la suma de las componentes de un array.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 int main()9 {10 const int arraySize = 10;11 12 int a[ arraySize ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };13 14 int total = 0;15 16 // suma contenidos del array a 17 for ( int i = 0; i < arraySize; i++ )18 total += a[ i ]; 19 20 cout << "La suma de los elementos del array es " << total << endl;21 22 return 0;23 24 }

La suma de los elementos del array es 55


Outline18

1 // Fig. 4.9: fig04_09.cpp2 // Gráfico de los valores de los elementos de un array con histogramas.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 int main()13 {14 const int arraySize = 10;15 int n[ arraySize ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };16 17 cout << "Elemento" << setw( 13 ) << "Valor"18 << setw( 17 ) << "Histograma" << endl;19 20 // para cada elemento del array n, imprimo una barra en histograma21 for ( int i = 0; i < arraySize; i++ ) {22 cout << setw( 7 ) << i << setw( 13 )23 << n[ i ] << setw( 9 ); 24 25 for ( int j = 0; j < n[ i ]; j++ ) // imprimo una barra26 cout << '*';

Imprime asteriscos correspondientes al tamaño del elemento n[i] del array.


Outline19

27 28 cout << endl; // siguiente línea de salida29 30 } // fin de estructura externa31 32 return 0;33 34 }

Elemento Valor Histograma

0 19 *******************

1 3 ***

2 15 ***************

3 7 *******

4 11 ***********

5 9 *********

6 13 *************

7 5 *****

8 17 *****************

9 1 *


Outline20

1 // Fig. 4.10: fig04_10.cpp2 // Tirar un dado 6000 veces y totalizar resultados en un array.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 #include <cstdlib>13 #include <ctime>14 15 int main()16 {17 const int arraySize = 7;18 int frecuencia[ arraySize ] = { 0 };19 20 srand( time( 0 ) ); // semilla del generador de números aleatorios21 22 // tiro el dado 6000 veces23 for ( int tirada = 1; tirada <= 6000; tirada++ ) 24 ++frecuencia[ 1 + rand() % 6 ]; // reemplaza el switch de 2025 // líneas de la Fig. 3.8

Reescribimos el programa visto de tirar un dado. Se usa un array en vez de 6 variables, y así el elemento puede actualizarse fácilmente (sin necesidad de un switch).

Se crea un número entre 1 y 6, que determina el índice de frecuencia[] que se debe incrementar.


Outline21

26 27 cout << "Cara" << setw( 13 ) << "Frecuencia" << endl;28 29 // Imprime la frecuencia de los elementos 1-6 en formato tabular30 for ( int cara = 1; cara < arraySize; cara++ ) 31 cout << setw( 4 ) << cara32 << setw( 13 ) << frecuencia[ cara ] << endl;33 34 return 0;35 36 }

Cara Frecuencia

1 1003

2 1004

3 999

4 980

5 1013

6 1001


Outline22

1 // Fig. 4.11: fig04_11.cpp2 // Uso de arrays para totalizar resultados de encuestas.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 int main()13 {14 // define los tamaños de los arrays15 const int tamRespuestas = 40; // tamaño del array respuestas16 const int tamFrecuencia = 11; // tamaño del array frecuencia17 18 // sitúa respuestas de la encuesta en array respuestas19 int respuestas[ tamRespuestas ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8,20 10, 1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7,21 5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };22 23 // inicializa contadores de frecuencia a 024 int frecuencia[ tamFrecuencia ] = { 0 };25

Encuesta: calidad comida cafetería alumnos (1=horrible, 10=excelente).

Nº encuestados: 40 alumnos


Outline23

26 // para cada i, selecciono el valor de un elemento del array27 // respuestas y uso ese valor como índice del array28 // frecuencia para determinar el elemento a incrementar29 for ( int i = 0; i < tamRespuestas; i++ )30 ++frecuencia[ respuestas[i] ];31 32 // imprimo resultados33 cout << "Puntuación" << setw( 17 ) << "Frecuencia" << endl;34 35 // imprimo frecuencias en formato tabular36 for ( int puntuacion = 1; puntuacion < tamFrecuencia; puntuacion++ )37 cout << setw( 6 ) << puntuacion38 << setw( 17 ) << frecuencia[ puntuacion ] << endl;39 40 return 0;41 42 }

respuestas[i] es la puntuación (de 1 a 10). Esto determina el índice a incrementar en frecuencia[].

Puntuación Frecuencia

1 2

2 2

3 2

4 2

5 5

6 11

7 5

8 7

9 1

10 3


24


• Uso de arrays para almacenar y manipular cadenas de caracteres o strings (más en capítulo 5)

– Arrays de caracteres

– Todas las cadenas terminan con null ('\0')

– Ejemplos• char cadena1[] = "hola";

– Carácter null añadido implícitamente

– cadena1 tiene 5 elementos

• char cadena1[] = { 'h', 'o', 'l', 'a', '\0’ };

– Los índices funcionan igual:cadena1[ 0 ] es 'h'

cadena1[ 2 ] es 'l'


25


• Entrada de tecladochar cadena2[ 10 ];

cin >> cadena2;

– Coloca la entrada del usuario en la variable• Finaliza cuando encuentra el primer espacio en blanco

• Añade el carácter null

– Si se introduce demasiado texto, los datos se escriben más allá del array

• Imprimir cadenas de caracteres– cout << string2 << endl;

• No funciona para otros tipos de arrays

– Los caracteres se imprimen hasta que se encuentra el carácter null


Outline26

1 // Fig. 4_12: fig04_12.cpp2 // Tratamiento de arrays de caracteres como cadenas.3 #include <iostream>4 5 using std::cout;6 using std::cin;7 using std::endl;8 9 int main()10 {11 char cadena1[ 20 ], // reserva 20 caracteres12 char cadena2[] = "cadena literal"; // reserva 15 caracteres13 14 // lee cadena del usuario y la mete en array string215 cout << "Introduzca la cadena \"hola amigos\": ";16 cin >> cadena1; // lee "hola" [el espacio finaliza la entrada]17 18 // imprimo cadenas19 cout << “cadena1 es: " << cadena1 20 << "\ncadena2 es: " << cadena2;21 22 cout << "\ncadena1 con espacios entre caracteres es:\n";23

Dos formas distintas de declarar cadenas. cadena2 se inicializa y su tamaño se determina automáticamente.

Ejemplos de lectura de cadenas del teclado y escritura de cadenas en pantalla.


Outline27

24 // imprimo caracteres hasta alcanzar el nulo25 for ( int i = 0; cadena1[ i ] != '\0'; i++ )26 cout << cadena1[ i ] << ' '; 27 28 cin >> cadena1; // lee "amigos"29 cout << "\ncadena1 es: " << cadena1 << endl;30 31 return 0;32 33 }

Introduzca la cadena "hola amigos": hola amigos

cadena1 es: hola

cadena2 es: cadena literal

cadena1 con espacios entre caracteres es:

h o l a

cadena1 es: amigos

Puedo acceder a caracteres en una cadena usando notación de arrays. El lazo finaliza cuando se encuentra el carácter null.


28

4.4 Ejemplos de uso de arrays

• Arrays locales estáticos y automáticos– Estáticos

• Si son static, las variables locales guardan sus valores entre llamadas a funciones

• Visibles sólo en el cuerpo de la función

• Se pueden declarar arrays estáticos

– Inicializados a cero

static int array[3];

– Si no son estáticos (automáticos)• Se crean (y destruyen) en cada llamada a la función


Outline29

1 // Fig. 4.13: fig04_13.cpp2 // Los arrays estáticos se inicializan a cero.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 void staticArrayInit( void ); // prototipo de función9 void automaticArrayInit( void ); // prototipo de función10 11 int main()12 {13 cout << "Primera llamada a cada función:\n";14 staticArrayInit();15 automaticArrayInit();16 17 cout << "\n\Segunda llamada a cada función:\n";18 staticArrayInit();19 automaticArrayInit();20 cout << endl;21 22 return 0; 23 24 }25


Outline30

26 // función para demostrar un array local estático27 void staticArrayInit( void )28 {29 // inicializa elementos a 0 la primera vez que se llama a la función30 static int array1[ 3 ]; 31 32 cout << "\nValores al entrar en staticArrayInit:\n";33 34 // imprimo contenidos de array135 for ( int i = 0; i < 3; i++ )36 cout << "array1[" << i << "] = " << array1[ i ] << " ";37 38 cout << "\nValores al salir de staticArrayInit:\n";39 40 // modifico e imprimo contenidos de array141 for ( int j = 0; j < 3; j++ )42 cout << "array1[" << j << "] = " 43 << ( array1[ j ] += 5 ) << " ";44 45 } // fin de función staticArrayInit46

Array estático, se inicializa a cero la primera vez que se llama a la función.

Se modifican los datos del array; los valores modificados permanecen.


Outline31

47 // función para demostrar un array local automático48 void automaticArrayInit( void )49 {50 // inicializa los elementos cada vez que se llama a la función51 int array2[ 3 ] = { 1, 2, 3 };52 53 cout << "\n\nValores al entrar en automaticArrayInit:\n";54 55 // imprime el contenido de array256 for ( int i = 0; i < 3; i++ )57 cout << "array2[" << i << "] = " << array2[ i ] << " ";58 59 cout << "\nValores al salir de automaticArrayInit:\n";60 61 // modifico e imprimo contenidos de array262 for ( int j = 0; j < 3; j++ )63 cout << "array2[" << j << "] = " 64 << ( array2[ j ] += 5 ) << " ";65 66 } // fin de función automaticArrayInit

Array automático, se vuelve a crear en cada llamada a la función.

Aunque el array se modifica, se destruirá cuando la función finalice y los cambios se perderán.


Outline32

Primera llamada a cada función:

Valores al entrar en staticArrayInit:

array1[0] = 0 array1[1] = 0 array1[2] = 0

Valores al salir de staticArrayInit:


Valores al entrar en automaticArrayInit:


Valores al salir de automaticArrayInit:


Segunda llamada a cada función:

Valores al entrar en staticArrayInit:


Valores al salir de staticArrayInit:


Valores al entrar en automaticArrayInit:


Valores al salir de automaticArrayInit:



33

4.5 Paso de arrays a funciones

• Se especifica el nombre sin corchetes– Para pasar el array miArray a miFuncion

int miArray[ 24 ];

miFuncion( miArray, 24 );

– Se suele pasar el tamaño del array, pero no es necesario• Útil para recorrer todos los elementos


34

4.5 Paso de Arrays a Funciones

• Los arrays se pasan por referencia– Las funciones pueden modificar los datos del array original

– El valor del nombre del array es la dirección del primer elemento

• La función sabe dónde está almacenado el array

• Puede modificar las localizaciones de memoria originales

• Los elementos individuales del array se pasan por valor– Como el resto de las variables– cuadrado( miArray[3] );


35

4.5 Paso de Arrays a Funciones

• Funciones que toman arrays– Prototipo de función

• void modificaArray( int b[], int arraySize );• void modificaArray( int [], int );

– Nombres opcionales en el prototipo

• Ambas toman un array de enteros y un entero

– No es necesario indicar el tamaño del array entre corchetes• El compilador lo ignora

– Si declaramos un parámetro array como const• No puede modificarse (error de compilación)• void noModifica( const int [] );


Outline36

1 // Fig. 4.14: fig04_14.cpp2 // Paso de arrays y elementos de un array a funciones.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 void modificaArray( int [], int ); // aspecto extraño13 void modificaElemento( int ); 14 15 int main()16 {17 const int tamArray = 5; // tamaño de array a18 int a[ tamArray ] = { 0, 1, 2, 3, 4 }; // inicializa a19 20 cout << "Efectos de pasar el array completo por referencia:" 21 << "\n\nLos valores del array original son:\n";22 23 // imprimo el array original24 for ( int i = 0; i < tamArray; i++ )25 cout << setw( 3 ) << a[ i ];

Sintaxis para aceptar un array en una lista de parámetros.


Outline37

26 27 cout << endl;28 29 // paso array a a modificaArray por referencia30 modificaArray( a, tamArray ); 31 32 cout << "Los valores del array modificado son:\n";33 34 // imprimo el array modificado35 for ( int j = 0; j < tamArray; j++ )36 cout << setw( 3 ) << a[ j ];37 38 // imprimo el valor de a[ 3 ]39 cout << "\n\n\n"40 << "Efectos de pasar un elemento del array por valor:"41 << "\n\nEl valor de a[3] es " << a[ 3 ] << '\n';42 43 // paso el elemento del array a[ 3 ] por valor44 modificaElemento( a[ 3 ] ); 45 46 // imprimo el valor de a[ 3 ]47 cout << "El valor de a[3] es " << a[ 3 ] << endl;48 49 return 0;50 51 }

Paso el nombre del array (a) y su tamaño a la función. Los arrays se pasan por referencia.

Paso un elemento del array por valor; el original no puede modificarse.


Outline38

52 53 // en función modificaArray, "b" apunta al 54 // array original "a" en memoria 55 void modificaArray( int b[], int tamañoDeArray )56 { 57 // multiplica cada elemento del array por 2 58 for ( int k = 0; k < tamañoDeArray; k++ ) 59 b[ k ] *= 2; 60 61 } // fin de la función modificaArray 62 63 // en función modificaElemento, "e" es una copia local del64 // elemento del array a[ 3 ] pasado desde main 65 void modificaElemento( int e ) 66 { 67 // multiplica parámetro por 2 68 cout << "Valor en modificaElemento es " 69 << ( e *= 2 ) << endl; 70 71 } // fin de la función modificaElemento

Aunque se llame b, el array apunta al array original a. Puede modificar los datos de a.

Los elementos individuales del array se pasan por valor, y los originales no pueden modificarse.


Outline39

Efectos de pasar el array completo por referencia:

Los valores del array original son:

0 1 2 3 4

Los valores del array modificado son:

0 2 4 6 8

Efectos de pasar un elemento del array por valor:

El valor de a[3] es 6

El valor en modificaElemento es 12

El valor de a[3] es 6


Outline40

1 // Fig. 4.15: fig04_15.cpp2 // Demostración del calificador de tipo const.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 void intentaModificarArray( const int [] ); // prototipo de función9 10 int main()11 {12 int a[] = { 10, 20, 30 };13 14 intentaModificarArray( a );15 16 cout << a[ 0 ] << ' ' << a[ 1 ] << ' ' << a[ 2 ] << '\n';17 18 return 0;19 20 }21

Parámetro array declarado como const. El array no puede modificarse, aún cuando se pasa por referencia.


Outline41

22 // en función intentaModificarArray, "b" no puede usarse23 // para modificar el array original "a" en main. 24 void intentaModificarArray( const int b[] ) 25 { 26 b[ 0 ] /= 2; // error 27 b[ 1 ] /= 2; // error 28 b[ 2 ] /= 2; // error 29 30 } // fin de la función intentaModificarArray

d:\cpphtp4_examples\ch04\Fig04_15.cpp(26) : error C2166: l-value specifies const object




42

4.6 Ordenación de Arrays

• Ordenación de datos– Una de las aplicaciones más importantes en computación

– Virtualmente cualquier organización debe ordenar algunos datos y, en muchos casos, cantidades masivas de datos

• Banco: ordena por nº de cuenta

• Guía de teléfonos: ordena por apellido

• Ordenación de burbuja– Varias pasadas por el array

– Se comparan parejas de elementos consecutivos• Si están en orden creciente (o idéntico), no se cambian

• Si están en orden decreciente, se intercambian

– Se repiten estos pasos para cada elemento


43


• Ejemplo:– Vamos de izquierda a derecha, e intercambiamos elementos

si es necesario• Una pasada para cada elemento

– Original: 3 4 2 7 6

– Paso 1: 3 2 4 6 7 (se intercambian los elementos)

– Paso 2: 2 3 4 6 7

– Paso 3: 2 3 4 6 7 (no se necesitan cambios)

– Paso 4: 2 3 4 6 7

– Paso 5: 2 3 4 6 7

– Los elementos menores “burbujean” hacia la izquierda (como el 2 en este ejemplo)


44


• Intercambio de variablesint x = 3, y = 4;

y = x;

x = y;

• ¿Qué sucede?– ¡Tanto x como y son 3!

– Se necesita una variable temporal

• Soluciónint x = 3, y = 4, temp;

temp = x; // temp toma el valor 3

x = y; // x toma el valor 4

y = temp; // y toma el valor 3


Outline45

1 // Fig. 4.16: fig04_16.cpp2 // Este programa ordena los valores de un array en orden ascendente.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 #include <iomanip>9 10 using std::setw;11 12 int main()13 {14 const int tamArray = 10; // tamaño del array a15 int a[ tamArray ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };16 int temp; // localización temporal usada para intercambio de elementos del array17 18 cout << "Datos en orden original\n";19 20 // imprimo el array original21 for ( int i = 0; i < tamArray; i++ )22 cout << setw( 4 ) << a[ i ];23


Outline46

24 // ordenación de burbuja25 // lazo que controla el número de pasadas26 for ( int paso = 0; paso < tamArray - 1; paso++ ) 27 28 // lazo que controla el número de comparaciones por paso29 for ( int j = 0; j < tamArray - 1; j++ ) 30 31 // compara elementos consecutivos y los intercambia si32 // el primer elemento es mayor que el segundo33 if ( a[ j ] > a[ j + 1 ] ) { 34 temp = a[ j ]; 35 a[ j ] = a[ j + 1 ]; 36 a[ j + 1 ] = temp; 37 38 } // fin de if 39

Se realiza una pasada por cada elemento del array.

Si el elemento de la izquierda (índice j) es mayor que el elemento a la derecha (índice j + 1), entonces los intercambiamos. Recordemos la necesidad de una variable temporal.


Outline47

40 cout << "\nDatos en orden ascendente\n";41 42 // imprimo el array ordenado43 for ( int k = 0; k < tamArray; k++ )44 cout << setw( 4 ) << a[ k ];45 46 cout << endl;47 48 return 0;49 50 }

Datos en orden original

2 6 4 8 10 12 89 68 45 37

Datos en orden ascendente

2 4 6 8 10 12 37 45 68 89


484.7 Caso de Estudio: Cálculo de Media, Mediana y Moda usando

Arrays• Análisis de resultados de una encuesta

– Media• Promedio (suma/número de elementos)

– Mediana• Valor en posición central de la lista ordenada

• 1, 2, 3, 4, 5 (3 es la mediana)

• Si el número de elementos es par, se toma el promedio de los dos del centro

– Moda• Respuesta (valor) más frecuente

• 1, 1, 1, 2, 3, 3, 4, 5 (1 es la moda)


Outline49

1 // Fig. 4.17: fig04_17.cpp2 // Este programa introduce el tema de análisis de datos.3 // Calcula la media, mediana y moda de los datos.4 #include <iostream>5 6 using std::cout;7 using std::endl;8 using std::fixed;9 using std::showpoint;10 11 #include <iomanip>12 13 using std::setw;14 using std::setprecision;15 16 void media( const int [], int );17 void mediana( int [], int );18 void moda( int [], int [], int );19 void ordenaBurbuja( int[], int );20 void imprimeArray( const int[], int );21 22 int main()23 {24 const int tamRespuestas = 99; // tamaño del array de respuestas25


Outline50

26 int frecuencia[ 10 ] = { 0 }; // inicializa array frecuencia27 28 // inicializa array respuestas29 int respuestas[ tamRespuestas ] = 30 { 6, 7, 8, 9, 8, 7, 8, 9, 8, 9,31 7, 8, 9, 5, 9, 8, 7, 8, 7, 8,32 6, 7, 8, 9, 3, 9, 8, 7, 8, 7,33 7, 8, 9, 8, 9, 8, 9, 7, 8, 9,34 6, 7, 8, 7, 8, 7, 9, 8, 9, 2,35 7, 8, 9, 8, 9, 8, 9, 7, 5, 3,36 5, 6, 7, 2, 5, 3, 9, 4, 6, 4,37 7, 8, 9, 6, 8, 7, 8, 9, 7, 8,38 7, 4, 4, 2, 5, 3, 8, 7, 5, 6,39 4, 5, 6, 1, 6, 5, 7, 8, 7 };40 41 // procesa respuestas42 media( respuestas, tamRespuestas );43 mediana( respuestas, tamRespuestas );44 moda( frecuencia, respuestas, tamRespuestas );45 46 return 0; 47 48 }49


Outline51

50 // calculamos el promedio de todos los valores respuesta51 void media( const int resp[], int tamArray )52 {53 int total = 0;54 55 cout << "********\n Media\n********\n";56 57 // total de valores respuesta58 for ( int i = 0; i < tamArray; i++ )59 total += resp[ i ];60 61 // formateo e imprimo resultados62 cout << setiosflags(ios::fixed) << setprecision( 4 );63 64 cout << "La media es el valor promedio de los datos\n"65 << "La media es igual al total de todos los datos\n"66 << "dividido por el número de datos (" << tamArray 67 << ").\nEl valor medio para este caso es:\n" 69 << total << " / " << tamArray << " = "70 << static_cast< double >( total ) / tamArray 71 << "\n\n";72 73 } // fin de función media74

Aplicamos un molde para obtener el promedio con decimales (en vez de un entero).


Outline52

75 // ordeno array y determino el valor del elemento mediana76 void mediana( int resp[], int tam )77 {78 cout << "\n********\n Mediana\n********\n"79 << "El array de respuestas desordenadas es";80 81 imprimeArray( resp, tam ); // imprimo array desordenado82 83 ordenaBurbuja( resp, tam ); // ordeno array84 85 cout << "\n\nEl array ordenado es";86 imprimeArray( resp, tam ); // imprime array ordenado87 88 // imprime elemento mediana89 cout << "\n\nLa mediana es el elemento " << tam / 290 << “\ndel array de " << tam << " elementos ordenados."91 << "\nPara este caso la mediana es "92 << resp[ tam / 2 ] << "\n\n";93 94 } // fin de función mediana95

Ordeno el array pasándolo a una función. Esto hace que el programa sea modular.


Outline53

96 // determina la respuesta más frecuente97 void moda( int frec[], int resp[], int tam )98 {99 int mayor = 0; // representa la mayor frecuencia100 int valorModa = 0; // representa la respuesta más frecuente101 102 cout << "\n********\n Moda\n********\n";103 104 // inicializa frecuencias a 0105 for ( int i = 1; i <= 9; i++ )106 frec[ i ] = 0;107 108 // calcula frecuencias109 for ( int j = 0; j < tam; j++ )110 ++frec[ resp[ j ] ];111 112 // imprime títulos de columnas de resultados113 cout << "Respuesta" << setw( 11 ) << "Frecuencia"114 << setw( 19 ) << "Histograma\n\n" << setw( 55 )115 << "1 1 2 2\n" << setw( 56 )116 << "5 0 5 0 5\n\n";117


Outline54

118 // salida de resultados119 for ( int puntos = 1; puntos <= 9; puntos++ ) {120 cout << setw( 8 ) << puntos << setw( 11 )121 << frec[ puntos ] << " ";122 123 // voy guardando los valores de moda y máxima frecuencia124 if ( frec[ puntos ] > mayor ) { 125 mayor = frec[ puntos ]; 126 valorModa = puntos; 127 128 } // fin del if 129 130 // imprimo histograma de barras que representan el valor de frecuencia131 for ( int k = 1; k <= frec[ puntos ]; k++ )132 cout << '*';133 134 cout << '\n'; // comienza nueva línea de salida135 136 } // fin del for externo137 138 // imprimo el valor de la moda139 cout << "La moda es el valor más frecuente.\n"140 << "Para este caso la moda es " << valorModa141 << " y ocurre " << mayor << " veces." << endl;142 143 } // fin de la función moda

La moda es el valor que ocurre más a menudo (tiene el valor más alto en frec).


Outline55

144 145 // función que ordena un array mediante el algoritmo de la burbuja146 void ordenaBurbuja( int a[], int tam )147 {148 int temp; // variable temporal para intercambiar elementos149 150 // lazo para controlar el número de pasos151 for ( int paso = 1; paso < tam; paso++ )152 153 // lazo para controlar el número de comparaciones por paso154 for ( int j = 0; j < tam - 1; j++ )155 156 // intercambio elementos desordenados157 if ( a[ j ] > a[ j + 1 ] ) {158 temp = a[ j ];159 a[ j ] = a[ j + 1 ];160 a[ j + 1 ] = temp;161 162 } // fin de if163 164 } // fin de la función ordenaBurbuja165


Outline56

166 // imprimo el contenido del array (20 valores por fila)167 void imprimeArray( const int a[], int tam )168 {169 for ( int i = 0; i < tam; i++ ) {170 171 if ( i % 20 == 0 ) // comienzo nueva línea cada 20 valores172 cout << endl;173 174 cout << setw( 2 ) << a[ i ];175 176 } // fin de for177 178 } // fin de función imprimeArray


Outline57

********

Media

********

La media es el valor promedio de los datos

La media es igual al total de todos los datos

dividido por el número de datos (99).

El valor medio para este caso es:

681 / 99 = 6.8788 ********

Mediana

********

El array de respuestas desordenado es

6 7 8 9 8 7 8 9 8 9 7 8 9 5 9 8 7 8 7 8

6 7 8 9 3 9 8 7 8 7 7 8 9 8 9 8 9 7 8 9

6 7 8 7 8 7 9 8 9 2 7 8 9 8 9 8 9 7 5 3

5 6 7 2 5 3 9 4 6 4 7 8 9 6 8 7 8 9 7 8

7 4 4 2 5 3 8 7 5 6 4 5 6 1 6 5 7 8 7

El array ordenado es

1 2 2 2 3 3 3 3 4 4 4 4 4 5 5 5 5 5 5 5

5 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7

7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8

8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8

9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

La mediana es el elemento 49 del

array de 99 elementos ordenados.

Para este caso la mediana es 7


Outline58

********

Moda

********

Respuesta Frecuencia Histograma

1 1 2 2

5 0 5 0 5

1 1 *

2 3 ***

3 4 ****

4 5 *****

5 8 ********

6 9 *********

7 23 ***********************

8 27 ***************************

9 19 *******************

La moda es el valor más frecuente.

Para este caso la moda es 8 y ocurre 27 veces.


59

4.8 Búsqueda en Arrays: Búsqueda Lineal y Búsqueda Binaria

• Busco un valor clave dentro del array• Búsqueda lineal

– Compara cada elemento del array con el valor clave• Comienza en un extremo y va hacia el otro

– Útil para pequeños arrays desordenados• Ineficiente

• Si la clave de búsqueda no existe, examina todos los elementos


60

4.8 Búsqueda en Arrays: Búsqueda Lineal y Búsqueda Binaria

• Búsqueda binaria– Sólo se usa con arrays ordenados

– Se compara el elemento en la posición central con la clave• Si son iguales, se encontró la clave

• Si clave < centro

– Repite la búsqueda en la primera mitad del array

• Si clave > centro

– Repite la búsqueda en la última mitad del array

– Algoritmo termina cuando clave=elemento central subarray

– Muy rápida • Como mucho N pasos, donde 2N > nº de elementos

• Un array de 30 elementos implica como mucho 5 pasos

25 > 30


Outline61

1 // Fig. 4.19: fig04_19.cpp2 // Búsqueda lineal en un array.3 #include <iostream>4 5 using std::cout;6 using std::cin;7 using std::endl;8 9 int busquedaLineal( const int [], int, int ); // prototipo10 11 int main()12 {13 const int tamArray = 100; // tamaño del array a14 int a[ tamArray ]; // crea array a15 int claveBusqueda; // valor a buscar en a16 17 for ( int i = 0; i < tamArray; i++ ) // crea algunos datos18 a[ i ] = 2 * i;19 20 cout << "Introduce un entero como clave de búsqueda: ";21 cin >> claveBusqueda;22 23 // busca claveBusqueda en array a 24 int elemento = busquedaLineal( a, claveBusqueda, tamArray );25

Toma el array, la clave de búsqueda, y el tamaño del array.


Outline62

26 // imprime resultados27 if ( elemento != -1 )28 cout << "Valor encontrado en elemento " << elemento << endl;29 else30 cout << "Valor no encontrado" << endl;31 32 return 0;33 34 }35 36 // compara la clave con todos los elementos del array hasta encontrar37 // su localización o hasta alcanzar el final del array; se devuelve38 // el índice del elemento o –1 si no se encuentra39 int busquedaLineal( const int array[], int clave, int tamDeArray )40 { 41 for ( int j = 0; j < tamDeArray; j++ ) 42 43 if ( array[ j ] == clave ) // si la encuentro,

44 return j; // devuelvo localización de clave45 46 return -1; // clave no encontrada 47 48 } // fin de función busquedaLineal

Introduce un entero como clave de búsqueda: 36

Valor encontrado en elemento 18

Introduce un entero como clave de búsqueda: 37

Valor no encontrado


Outline63

1 // Fig. 4.20: fig04_20.cpp2 // Búsqueda binaria en un array.3 #include <iostream>4 5 using std::cout;6 using std::cin;7 using std::endl;8 9 #include <iomanip>10 11 using std::setw;12 13 // prototipos de funciones14 int busquedaBinaria( const int [], int, int, int, int );15 void imprimeCabecera( int );16 void imprimeFila( const int [], int, int, int, int );17 18 int main()19 {20 const int tamArray = 15; // tamaño del array a21 int a[ tamArray ]; // crea array a22 int clave; // valor a localizar en a23 24 for ( int i = 0; i < tamArray; i++ ) // crea algunos datos25 a[ i ] = 2 * i; 26 27 cout << "Introduce un número entre 0 y 28: ";28 cin >> clave;29


Outline64

30 imprimeCabecera( tamArray );31 32 // busco la clave en el array a33 int resultado = 34 busquedaBinaria( a, clave, 0, tamArray - 1, tamArray );35 36 // imprimo resultados37 if ( resultado != -1 )38 cout << '\n' << clave << " encontrada en el elemento "39 << resultado << "del array" << endl;40 else41 cout << '\n' << clave << " no encontrada" << endl;42 43 return 0;44 45 }46 47 // función que realiza la búsqueda binaria en un array48 int busquedaBinaria( const int b[], int claveBusqueda, int menor, 49 int mayor, int tam )50 {51 int medio;52 53 // lazo hasta que el índice menor es mayor que el mayor54 while ( menor <= mayor ) {55 56 // determino el elemento central del subarray en el que se busca57 medio = ( menor + mayor ) / 2; 58

Determina elemento central


Outline65

59 // imprimo subarray usado en esta iteración60 imprimeFila( b, menor, medio, mayor, tam );61 62 // si la clave de búsqueda está en el elemento central, devuelve medio63 if ( claveBusqueda == b[ medio ] ) // coinciden64 return medio;65 66 else 67 68 // si la clave de búsqueda es menor que el elemento del medio, 69 // calculo el nuevo elemento mayor70 if ( claveBusqueda < b[ medio ] )71 mayor = medio - 1; // busco en la mitad inferior del array72 73 // si la clave de búsqueda es mayor que el elemento del medio, 74 // calculo el nuevo elemento menor75 else76 menor = medio + 1; // busco en la mitad superior del array77 }78 79 return -1; // clave de búsqueda no encontrada80 81 } // fin de la función busquedaBinaria

Usa la regla de búsqueda binaria:Si clave=medio, coinciden

Si es menor, busco en mitad inferior

Si es mayor, busco en mitad superior

El lazo calcula menor, mayor y medio dinámicamente. Si la búsqueda es en la mitad superior, menor será el elemento después de medio.


Outline66

82 83 // imprime la cabecera para la salida84 void imprimeCabecera( int tam )85 {86 cout << "\nÍndices:\n";87 88 // imprime cabeceras de columna89 for ( int j = 0; j < tam; j++ )90 cout << setw( 3 ) << j << ' ';91 92 cout << '\n'; // comienza nueva línea de salida93 94 // salida de línea de caracteres -95 for ( int k = 1; k <= 4 * size; k++ )96 cout << '-';97 98 cout << endl; // comienza nueva línea de salida99 100 } // fin de función imprimeCabecera101


Outline67

102 // imprime una fila de salida mostrando la parte del array103 // que está siendo procesada104 void imprimeFila( const int b[], int menor, int medio, 105 int mayor, int tam )106 {107 // lazo que recorre el array108 for ( int m = 0; m < tam; m++ )109 110 // imprime espacios si estamos fuera del rango del subarray actual111 if ( m < menor || m > mayor )112 cout << " ";113 114 // imprime elemento central marcándolo con un *115 else 116 117 if ( m == medio ) // marca valor medio118 cout << setw( 3 ) << b[ m ] << '*'; 119 120 // imprime los demás elementos del subarray121 else122 cout << setw( 3 ) << b[ m ] << ' ';123 124 cout << endl; // comienza nueva línea de salida125 126 } // fin de función imprimeFila


Outline68

Introduce un número entre 0 y 28: 6

Índices:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

------------------------------------------------------------

0 2 4 6 8 10 12 14* 16 18 20 22 24 26 28

0 2 4 6* 8 10 12

6 encontrado en el elemento 3 del array


Índices:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

------------------------------------------------------------

0 2 4 6 8 10 12 14* 16 18 20 22 24 26 28

16 18 20 22* 24 26 28

24 26* 28

24*

25 no encontrado


Outline69


Índices:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

------------------------------------------------------------

0 2 4 6 8 10 12 14* 16 18 20 22 24 26 28

0 2 4 6* 8 10 12

8 10* 12

8*

8 encontrado en el elemento 4 del array


70

4.9 Arrays Multi-Dimensionales

• Múltiples índices– a[ i ][ j ]– Uso común: Representación de tablas con filas y columnas

– Especificar un elemento: Especifico fila, y después columna

– “Array de arrays”• a[0] es un array de 4 elementos• a[0][0] es el primer elemento de ese array

Fila 0

Fila 1

Fila 2

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

a[ 1 ][ 0 ]

a[ 2 ][ 0 ]

a[ 0 ][ 1 ]

a[ 1 ][ 1 ]

a[ 2 ][ 1 ]

a[ 0 ][ 2 ]

a[ 1 ][ 2 ]

a[ 2 ][ 2 ]

a[ 0 ][ 3 ]

a[ 1 ][ 3 ]

a[ 2 ][ 3 ]

Índice de Fila

Nombre array

Índice de Columna


71


• Para inicializarlos– Por defecto a 0– Inicializadores agrupados mediante filas entre llavesint b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };

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

1 2

3 4

1 0

3 4

Fila 0 Fila 1


72


• Se referencian como los demás arrayscout << b[ 0 ][ 1 ];

– Imprime 0– No se pueden usar comas en las referencias

cout << b[ 0, 1 ];• Error de sintaxis

• Prototipos de funciones– Deben especificar tamaños de índices

• Primer tamaño no necesario, como con arrays de 1 dimensión

– void imprimeArray( int [][ 3 ] );

1 0

3 4


Outline73

1 // Fig. 4.22: fig04_22.cpp2 // Inicialización de arrays multidimensionales.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 8 void imprimeArray( int [][ 3 ] );9 10 int main()11 {12 int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } };13 int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 }; 14 int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } }; 15 16 cout << "Valores en array1 por filas son:" << endl;17 imprimeArray( array1 );18 19 cout << "Valores en array2 por filas son:" << endl;20 imprimeArray( array2 );21 22 cout << "Valores en array3 por filas son:" << endl;23 imprimeArray( array3 );24 25 return 0;26 27 }

Notad los distintos estilos de inicialización. Los elementos del array2 son asignados a la primera fila y después a la segunda.

Notad el formato del prototipo.


Outline74

28 29 // función para imprimer el array con 2 filas y 3 columnas30 void imprimeArray( int a[][ 3 ] ) 31 { 32 for ( int i = 0; i < 2; i++ ) { // para cada fila33 34 for ( int j = 0; j < 3; j++ ) // imprime valores de columna35 cout << a[ i ][ j ] << ' '; 36 37 cout << endl; // comienza nueva línea de salida38 39 } // fin de la estructura externa40 41 } // fin de la función imprimeArray

Valores en array1 por filas son:

1 2 3

4 5 6


1 2 3

4 5 0


1 2 0

4 0 0

Los lazos for suelen usarse para recorrer los arrays. Los lazos anidados son útiles para arrays multidimensionales.


75


• Ejemplo: programa para guardar las notas de 4 exámenes realizados por 3 alumnos– Array multi-dimensional (tabla)

– Las filas son los alumnos (3)

– Las columnas son las notas (4)

95 85

89 80

Exam1 Exam2

Alumno0

Alumno1


Outline76

1 // Fig. 4.23: fig04_23.cpp2 // Ejemplo de array de 2 dimensiones.3 #include <iostream>4 5 using std::cout;6 using std::endl;7 using std::fixed;8 using std::left;9 10 #include <iomanip>11 12 using std::setw;13 using std::setprecision;14 15 const int alumnos = 3; // número de alumnos16 const int examenes = 4; // número de exámenes17 18 // prototipos de funciones19 int minimo( int [][ examenes ], int, int );20 int maximo( int [][ examenes ], int, int );21 double promedio( int [], int );22 void imprimeArray( int [][ examenes ], int, int );23


Outline77

24 int main()25 {26 // inicializo notas de alumnos para 3 alumnos (filas)27 int notasAlumnos[ alumnos ][ examenes ] = 28 { { 77, 68, 86, 73 },29 { 96, 87, 89, 78 },30 { 70, 90, 86, 81 } };31 32 // imprimo array notasAlumnos33 cout << "El array es:\n";34 imprimeArray( notasAlumnos, alumnos, examenes );35 36 // determina las notas mayor y menor37 cout << "\n\nNota mínima: "38 << minimo( notasAlumnos, alumnos, examenes ) 39 << "\nNota máxima: "40 << maximo( notasAlumnos, alumnos, examenes ) << '\n';41 42 cout << setiosflags(ios::fixed) << setprecision( 2 );43


Outline7844 // calcula la nota media para cada alumno

45 for ( int persona = 0; persona < alumnos; persona++ )46 cout << "La nota media para el alumno " << persona 47 << " es " 48 << promedio( notasAlumnos[ persona ], examenes ) 49 << endl;50 51 return 0;52 53 }54 55 // busca la nota mínima56 int minimo( int notas[][ examenes ], int alum, int tests )57 {58 int notaMenor = 100; // inicializa a la nota más alta posible59 60 for ( int i = 0; i < alum; i++ ) 61 62 for ( int j = 0; j < tests; j++ ) 63 64 if ( notas[ i ][ j ] < notaMenor )65 notaMenor = notas[ i ][ j ];66 67 return notaMenor;68 69 } // fin de la función minimo70

Determina el promedio para un alumno. Pasamos el array/fila que contiene las notas del alumno. Notad que notasAlumnos[0] también es un array.


Outline79

71 // busca la nota máxima72 int maximo( int notas[][ examenes ], int alum, int tests )73 {74 int notaMayor = 0; // inicializa a la menor nota posible75 76 for ( int i = 0; i < alum; i++ )77 78 for ( int j = 0; j < tests; j++ )79 80 if ( notas[ i ][ j ] > notaMayor )81 notaMayor = notas[ i ][ j ];82 83 return notaMayor;84 85 } // fin de la función maximo86 87 // calculo la nota media de un alumno88 double promedio( int notas[], int tests ) 89 { 90 int total = 0; 91 92 // suma todas las notas de un alumno93 for ( int i = 0; i < tests; i++ ) 94 total += notas[ i ]; 95 96 return static_cast< double >( total ) / tests; // promedio97 98 } // fin de función maximo


Outline80

99 100 // Imprime el array101 void imprimeArray( int notas[][ examenes ], int alum, int tests )102 {103 // Fijo alineación a la izquierda e imprimo cabeceras de columnas104 cout << setiosflags(ios::left) << " [0] [1] [2] [3]";105 106 // imprimo notas en formato tabular107 for ( int i = 0; i < alum; i++ ) {108 109 // imprimo etiqueta de fila110 cout << "\nnotasAlumnos[" << i << "] ";111 112 // imprimo notas de alumno i113 for ( int j = 0; j < tests; j++ )114 cout << setw( 5 ) << notas[ i ][ j ];115 116 } // fin del for externo117 118 } // fin de la función imprimeArray


Outline81

El array es:

[0] [1] [2] [3]

notasAlumnos[0] 77 68 86 73



Nota mínima: 68

Nota máxima: 96

La nota media para el alumno 0 es 76.00



Documents

2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 4 - Arrays Índice del Capítulo 4.1Introducción 4.2Arrays 4.3Declaración de Arrays 4.4Ejemplos