CONTENIDO DE LA LECCIÓN 18

MIGUEL Á. TOLEDO MARTÍNEZ
CONTENIDO DE LA LECCIÓN 18
ALMACENAMIENTO DE DATOS EN ARREGLOS
1. Introducción 3
2. Estructura de un arreglo 3
2.1. Elementos del arreglo 5
2.2. Índice del arreglo 5
3. Examen breve 34 76
4. Definición de arreglos unidimensionales en C++ 5
4.1. Formato para un arreglo unidimensional 5
4.2. Ejemplo 18.1 6
5. Examen breve 35 76
6. El acceso a los arreglos 6
6.1. Inserción de elementos en los arreglos unidimensionales 6
6.1.1. Asignación directa 6
6.1.1.1. Formato de asignación directa (inserción de elementos en un arreglo) 6
6.1.2. Sugerencia de depuración 7
6.1.3. Lectura de los elementos del arreglo 7
6.1.4. Inserción de elementos del arreglo con el uso de ciclos 8
6.1.4.1. Inserción dentro de un arreglo unidimensional con el uso de un ciclo for 8
7. Extracción de elementos de los arreglos unidimensionales 9
7.1. Asignación directa 9
7.1.1. Formato de asignación directa (extracción de elementos del arreglo) 9
7.1.2. Escritura de elementos del arreglo 10
7.1.3. Extracción de elementos del arreglo con el uso de ciclos 10
7.1.4. Sugerencia de depuración 11
8. Examen breve 36 76
9. Ejemplos 18.2, 18.3, 18.4, 18.5, 18.6, 18.7, 18.8, 18.9, 18.10, 18.11, 18.12, 18.13, 18.14,
18.15, 18.16, 18.17. 12
10. Paso de arreglos y elementos de arreglos a las funciones 21
10.1. Ejemplos 18.18, 18.19, 18.20, 18.21, 18.22, 18.23, 18.24, 18.25 21
11. Examen breve 37 76
12. Ordenamiento de arreglos 31
12.1. Ejemplos 18.26, 18.27, 18.28, 18.29, 18.30, 18.31, 18.32 32
13. Búsqueda en arreglos: Búsqueda lineal y búsqueda binaria 40
13.1. Ejemplos 18.33, 18.34, 18.35 40
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-1

MIGUEL Á. TOLEDO MARTÍNEZ
14. Solución de problemas en acción: Búsqueda en un arreglo con iteración
(búsqueda secuencial) 45
14.1. Problema 45
14.2. Definición del problema 45
14.3. Planeación de la solución 46
14.4. Codificación del programa 46
15. Solución de problemas en acción: Como ordenar un arreglo con iteración
(ordenación por inserción) 47
15.1. Problema 47
15.2. Definición del problema 47
15.3. Planeación de la solución 48
15.4. Codificación del problema 50
16. Solución de problemas en acción: Búsqueda en un arreglo con recursión
(búsqueda binaria) 51
16.1. Problema 51
16.2. Definición del problema 51
16.3. Planeación de la solución 52
16.4. Codificación del problema 55
17. Ejemplos 18.36, 18.37 56
18. Iniciación de arreglos 61
18.1. Iniciación predeterminada de arreglos globales y estáticos 63
19. Examen breve 38 77
20. Arreglos que rebasan los 64 kbytes de memoria 65
20.1. Ejemplos 18.38 y 18.39 65
21. Lo que necesita saber 66
22. Preguntas y problemas 68
22.1. Preguntas 68
22.2. Problemas 70
22.3. Problemas de recursividad 75
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-2

MIGUEL Á. TOLEDO MARTÍNEZ
LECCIÓN 18
ALMACENAMIENTO DE DATOS EN ARREGLOS
INTRODUCCIÓN
Esta lección tratará un tema muy importante en cualquier lenguaje de programación: los
arreglos. No es posible enfatizar sobremanera la importancia de los arreglos, pues ellos mismos
dan origen a muchas aplicaciones.
En muchas ocasiones, sus programas requerirán almacenar varios valores, tales como 50
calificaciones, 10 títulos de libros, 1000 nombres de archivos, etc. Cuando sus programas
necesitan almacenar varios valores, entonces define un arreglo, especificando su clase de datos,
nombre y número de elementos que el arreglo almacenará.
Un arreglo es una estructura de datos indexados que se utiliza para almacenar elementos de datos
de la misma clase.
Los arreglos simplemente proporcionan un medio organizado para localizar y almacenar
datos, así como el apartado postal en el correo de su oficina postal local proporciona un medio
organizado de localizar y clasificar el correo. Por esto a un arreglo se le conoce como una
estructura de datos que se usa para almacenar cualquier clase de datos, incluyendo enteros,
flotantes, caracteres, arreglos, apuntadores, y registros (structs) Además, los arreglos son tan
versátiles que se pueden usar para implementar otras estructuras de datos, como pilas, colas,
listas ligadas y árboles binarios, de hecho en algunos lenguajes corno FORTRAN, el arreglo es la
única estructura de datos disponible para el programador, porque, por medio del uso de arreglos
es posible implementar la mayor parte de otras estructuras.
Los objetivos de esta lección son:
• Presentar la estructura de datos de arreglo.
• Declarar un arreglo dentro de su programa.
• Comprender cómo se declaran e inicializan los arreglos y de qué manera se hace referencia a
los elementos de un arreglo.
• Aprender a pasar los arreglos a las funciones
• Aprender a utilizar los arreglos para almacenar, ordenar y hacer búsquedas en listas y tablas
de valores.
• Discernir las técnicas básicas para el ordenamiento.
ESTRUCTURA DE UN ARREGLO
Un arreglo es una estructura de datos. En otras palabras, un arreglo consta de elementos
de datos organizados o estructurados en una forma particular. Esta estructura de datos
proporciona un medio conveniente para almacenar grandes cantidades de datos en la memoria
primaria o del usuario. Existen arreglos unidimensionales o listas y multidimensionales.
En esta lección revisaremos los arreglos unidimensionales; en la lección 19
estudiaremos los arreglos multidimensionales.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-3

MIGUEL Á. TOLEDO MARTÍNEZ
Para obtener la idea de un arreglo, observe la ilustración de la figura 18.1. En esta figura
se puede ver una sola línea de cajas de apartados postales como se encuentran en cualquier
oficina de correos. Como se sabe, cada caja tiene un número de apartado postal (A. P.) En la
figura 18.1, los números del A. P. empiezan con cero y van hasta un número finito n. ¿Cómo se
localiza una determinada caja? Por medio del número de apartado postal, ¿correcto? Sin
embargo, el número del A. P. no tiene nada que ver con lo que contiene la caja. Simplemente se
usa para localizar una caja determinada. Desde luego, el contenido es la correspondencia enviada
a esta caja. La razón por la que el servicio postal usa el método de apartado postal es que
proporciona un método conveniente y bien organizado para almacenar y tener acceso a la
correspondencia de sus clientes. Un arreglo hace lo mismo en un programa de computadora;
proporciona un método conveniente y bien organizado para almacenar y tener acceso a los datos
para usted, el programador. De modo que, ¿cuántos apartados postales hay en la figura 18.1?
Debido a que el primer número del apartado es 0 y el último es n, habrá n + 1 apartados.
APARTADO
POSTAL 0
Figura 18.1.Un arreglo unidimensional o lista es como una fila de buzones de apartados en la
oficina de correos.
Imagine que un arreglo unidimensional, como el que se muestra en la figura 18.2, es
similar a una línea de cajas de apartados postales. El arreglo unidimensional consiste en una sola
fila de lugares de almacenamiento, cada una etiquetada con un número que se conoce con el
nombre de índice. Cada localización del índice se utiliza para almacenar una clase de datos
determinada. Los datos almacenados en una localización de índice determinada se conoce como
elemento del arreglo. De esta manera, un arreglo unidimensional es una lista secuencial de
lugares de almacenamiento que contiene elementos de datos individuales que se localizan o
accedan por medio de índices.
Elemento
0
APARTADO
POSTAL 1
Elemento
1
APARTADO
POSTAL 2
Elemento
2
APARTADO
POSTAL 3
Elemento
3
[0] [1] [2] [3] [n]
ÍNDICES
Figura 18.2 Un arreglo unidimensional, también llamado lista, es una lista secuencial de
localizaciones de almacenamiento que contiene los elementos de datos que se
localizan por medio de los índices.
Los dos componentes principales de un arreglo son los elementos almacenados en el
arreglo y los índices que localizan los elementos almacenados. ¡No se confunda con estos dos
componentes del arreglo! Aunque los elementos del arreglo y los índices se relacionan, son
cantidades completamente separadas, al igual que el contenido de una caja de apartado postal es
diferente de su número de apartado. Con esto presente, vamos a explorar los elementos e índices
del arreglo un poco más a fondo.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-4
...
...
APARTADO
POSTAL n
Elemento
n

MIGUEL Á. TOLEDO MARTÍNEZ
ELEMENTOS DEL ARREGLO
Los elementos de un arreglo son los datos almacenados en éste y pueden ser de
cualquier clase de datos que se hayan visto. De esta manera, un arreglo dado puede almacenar
elementos enteros, elementos de punto flotante, caracteres, y elementos booleanos. Además,
de estos elementos de clase de datos estándar, un arreglo también es útil para almacenar
elementos de datos enumerados. De hecho, aun los elementos de un arreglo pueden ser otros
arreglos. Sin embargo, existe una restricción importante que se aplica a los elementos del
arreglo: todos los elementos de un arreglo determinado deberán ser de la misma clase de datos.
Como se verá en breve, es necesario definir los arreglos en un programa C++. Parte de la
definición es especificar la clase de los elementos que el arreglo almacenará. Una vez que se ha
definido un arreglo determinado para cierta clase de datos, sólo los elementos de esa clase de
datos se almacenarán en ese arreglo.
ÍNDICES DEL ARREGLO
Los índices del arreglo localizan a los elementos del arreglo, en C++, el compilador en
forma automática asigna índices enteros a la lista de elementos del arreglo empezando con el
índice 0. Por lo tanto, el primer elemento del arreglo en la figura 18.2 se localiza en el índice 0,
y el último elemento se localiza en el índice n. Los índices empiezan con 0 y van a n, por tanto
habrá n + 1 elementos en el arreglo. También, debido a que es un arreglo unidimensional, o
lista, decimos que tiene una dimensión de 1 ×××× (n + 1) lo cual significa que hay un renglón de n +
1 elementos. La dimensión de un arreglo indica el tamaño del arreglo, justo como la dimensión
de una pieza de madera indica su tamaño.
DEFINICIÓN DE ARREGLOS UNIDIMENSIONALES EN C++
cosas:
En C++ todos los arreglos deberán estar definidos. Para definir un arreglo, especifique 3
1. La clase de datos de los elementos del arreglo.
2. El nombre del arreglo.
3. El tamaño del arreglo.
El formato general es como sigue:
EXAMEN BREVE 34
FORMATO PARA UN ARREGLO UNIDIMENSIONAL
[];
Lo primero que se ve en la definición es la clase de datos de los elementos del arreglo.
La clase de datos del arreglo es seguida por el identificador del arreglo, su nombre, el cual es
seguido por el número de elementos que almacena el arreglo dentro de los corchetes, [] La
definición termina con un punto y coma. Por ejemplo, la siguiente es una definición de un
arreglo de 10 caracteres cuyo nombre es caracteres.
char caracteres [10];
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-5

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.1
Escriba las definiciones para los siguientes arreglos:
a. Un arreglo llamado enteros que almacenará 10 enteros.
b. Un arreglo llamado reales que almacenará 5 valores de punto flotante.
c. Un arreglo llamado caracteres que almacenará 11 caracteres.
d. Un arreglo llamado clase que almacenará calificaciones de 25 estudiantes. Suponga que las
calificaciones A, B, C, D y R se definen en una clase de datos enumerados denominada calificaciones.
¿Qué índice localiza el último elemento en cada uno de los arreglos anteriores?
a. int enteros[10];
b. float reales[5];
c. char caracteres[11];
d. enum calificaciones {R, D, C, B, A};
e. calificaciones clase[25];
Solución
El índice que localiza el último elemento en cada uno de los arreglos anteriores es uno
menos que el tamaño definido del arreglo.
En cada una de las definiciones anteriores se menciona primero la clase de datos del elemento, seguida por
el identificador del arreglo, después el tamaño del arreglo encerrado en corchetes. Cada una de las
definiciones es muy obvia, excepto quizá la definición del arreglo clase. En esta definición, la clase de
datos del arreglo es la clase de datos enumerada llamada calificaciones, que deberá anunciarse antes de la
definición del arreglo. Por tanto, diremos que el arreglo clase puede almacenar elementos cuya clase de
datos sean calificaciones. De esta manera, los elementos que se pueden almacenar en el arreglo clase se
limitan a los elementos de la clase de datos enumerados de R, D, C, B y A. Observe que el compilador no
los considera como caracteres, sino como elementos de una clase de datos enumerados llamada
calificaciones.
EL ACCESO A LOS ARREGLOS
Tener acceso al arreglo significa insertar elementos dentro del arreglo para almacenar u
obtener elementos almacenados desde el arreglo.
INSERCIÓN DE ELEMENTOS EN LOS ARREGLOS UNIDIMENSIONALES
Hay básicamente 3 formas principales de insertar elementos dentro de un arreglo:
mediante un enunciado de asignación directa, mediante lectura o usando ciclos.
ASIGNACIÓN DIRECTA
EXAMEN BREVE 35
El formato general para insertar un elemento, dentro un arreglo, con asignación directa
es como sigue:
FORMATO DE ASIGNACIÓN DIRECTA (INSERCIÓN DE ELEMENTOS EN UN ARREGLO)
[índice del arreglo] = valor del elemento;
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-6

MIGUEL Á. TOLEDO MARTÍNEZ
Con las siguientes definiciones de arreglos:
char caracteres[6];
int enteros[3];
las asignaciones directas pueden ser como estas:
caracteres [0] ='H';
caracteres [5] ='\0';
enteros [0] = 16;
enteros [2] = -22;
En cada uno de estos ejemplos se coloca un elemento en la primera y en la última
posición de almacenamiento del arreglo respectivamente. El carácter 'H' se coloca en la primera
posición del arreglo caracteres y el terminador nulo se coloca en la última posición de este
arreglo. Recuerde que la primera posición de este arreglo es siempre [0] y la última posición del
arreglo es siempre uno menos que el tamaño del arreglo. El entero 16 se coloca en la primera
posición del arreglo enteros y el entero -22 se coloca en la última posición de este arreglo.
Observe que se menciona el nombre respectivo del arreglo, seguido por el índice del
arreglo dentro de corchetes. Entonces se usa un operador de asignación (=) seguido por el
elemento que se va a insertar. La clase de datos del elemento que se inserta deberá ser la misma
que aquella definida para los elementos del arreglo; de otra manera, se obtendrán resultados
impredecibles cuando se trabaje con los elementos del arreglo.
SUGERENCIA DE DEPURACIÓN
Recuerde que los índices de un arreglo en C++ son valores enteros. Esto significa que cualquier índice
especificado se convierte en su equivalente entero. Por ejemplo, es posible especificar un índice como un carácter
como este: arreglo['A’]; sin embargo, C++ trata esto como arreglo[65], porque, desde el código ASCII, el
equivalente entero del carácter ‘A’ es 65. De la misma manera, se puede especificar un índice usando un valor de
punto flotante, como este: arreglo[1.414], sin embargo, C++ lo ve como arreglo[1], porque la parte entera de
1.414 es 1. Los elementos de datos enumerados también se pueden usar como índices, porque el compilador iguala
los elementos enumerados a enteros, de acuerdo con el orden listado en el enunciado de la clase de datos
enumerados. Para evitar confusión y problemas potenciales, se sugiere utilizar siempre valores enteros en los
índices, a menos que la aplicación específicamente indique otra cosa.
LECTURA DE LOS ELEMENTOS DEL ARREGLO
También es posible usar cualquiera de las funciones u objetos de entrada de C o C++ para
insertar los elementos del arreglo desde un teclado, como sigue:
cin > caracteres[1];
cin > enteros[0];
En este caso, el usuario deberá escribir el valor del elemento del arreglo respectivo desde
el teclado y oprimir la tecla ENTER para ejecutar cada enunciado. Deberá escribir un carácter
para el primer enunciado cin y un entero para el segundo cin. (¿Por qué?) El carácter escrito
desde el teclado se almacenará en la segunda posición (índice[1]) del arreglo caracteres,
mientras que el entero escrito desde el teclado se almacenará en la primera posición (índice[0])
del arreglo enteros.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-7

MIGUEL Á. TOLEDO MARTÍNEZ
INSERCIÓN ELEMENTOS DE ARREGLOS CON EL USO DE CICLOS
La desventaja obvia al usar asignaciones directas para insertar elementos de arreglos es
que se requiere un enunciado de asignación separado para llenar cada posición del arreglo. Puede
automatizar el proceso de inserción usando una estructura de ciclo. Aunque cualquiera de las tres
estructuras de ciclo (while, do/while, for) se puede emplear, la estructura for es la más común. A
continuación está el formato general para el uso de un ciclo for:
INSERCIÓN DENTRO DE UN ARREGLO UNIDIMENSIONAL CON EL USO DE UN CICLO for
Considere el siguiente programa:
for(int indice = 0; indice < tamaño del arreglo; ++indice)
//LLENADO DE UN ARREGLO CON UN CICLO for
#include // Para cin y cout
// DECLARA EL TAMAÑO DEL ARREGLO
const int MAX = 10;
void main(void)
{
int muestra[MAX]; // DEFINE UN ARREGLO ENTERO
cout

MIGUEL Á. TOLEDO MARTÍNEZ
del arreglo muestra[MAX – 1] Cuando el contador de ciclo se incremento al valor MAX al final
de la última iteración de ciclo, éste se rompe y no se insertan más elementos dentro del arreglo.
¡Eso es todo! ¡El arreglo está lleno!
También puede usar ciclos para asignar valores a los elementos del arreglo. Por ejemplo,
usando las definiciones anteriores, considere este ciclo:
for (int i = 0; i < MAX; ++i)
muestra[i] = 2 * i;
Esta vez, los elementos del arreglo se asignan dos veces al valor del contador de ciclo con
cada iteración de ciclo. ¿Qué valores se insertan realmente dentro del arreglo? ¿Qué pasa
con los 10 enteros pares de 0 a 18?
EXTRACCIÓN DE ELEMENTOS DE LOS ARREGLOS UNIDIMENSIONALES
Primero, se le advierte que la palabra extraer no es un buen término aquí. ¿Por qué?
Porque, en general, la palabra extraer significa eliminar algo, cuando extraemos un elemento de
un arreglo, ¡realmente no lo eliminamos! Simplemente copiamos su valor. El elemento
permanece almacenado en el arreglo hasta que se reemplaza por otro valor usando una operación
de inserción. Como con la inserción, es posible extraer elementos del arreglo usando uno de los
tres métodos generales: asignación directa, escritura o ciclo.
ASIGNACIÓN DIRECTA
La extracción de los elementos del arreglo usando enunciados de asignación es lo
inverso de la inserción de elementos utilizando un enunciado de asignación. Éste es el formato
general:
FORMATO DE ASIGNACIÓN DIRECTA (EXTRACCIÓN DE ELEMENTOS DEL ARREGLO)
= [índice del arreglo]
Como ejemplo, suponga que se hacen las siguientes definiciones:
const int MAX = 10;
int muestra[MAX];
int x;
Como puede observar, el arreglo muestra[] consta de 10 elementos enteros. Ahora,
suponga que el arreglo está lleno, ¿Qué harán los siguientes enunciados?
x = muestra[0];
x = muestra[MAX - 1];
x = muestra[3] * muestra[5];
x = 2 * muestra[2] -3 * muestra[7];
El primer enunciado asigna el elemento almacenado en la primera posición del arreglo a
la variable x. El segundo enunciado asigna el elemento almacenado en la última posición del
arreglo a la variable x. El tercer enunciado asigna el producto de los elementos localizados en los
índices [3] y [5] a x. Por último, el cuarto enunciado asigna a x dos veces el elemento localizado
en el índice[2] menos tres veces el elemento localizado en el índice [7] Los últimos dos
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-9

MIGUEL Á. TOLEDO MARTÍNEZ
enunciados muestran cómo se pueden realizar las operaciones aritméticas con los elementos del
arreglo.
En todos los casos anteriores, los valores de los elementos del arreglo no se afectan por
las operaciones de asignación. El principal requerimiento es que x debe estar definida como la
misma clase de datos de los elementos del arreglo para no obtener resultados inesperados.
Como ejemplo final, considere estos enunciados de asignación:
muestra[0] = muestra[MAX - 1];
muestra[1] = Muestra[2] + Muestra[3];
¿Puede usted determinar qué pasa aquí? En el primer enunciado, el primer elemento
del arreglo se reemplaza por medio del último elemento del arreglo, ¿se afecta el último
elemento del arreglo? No, porque aparece del lado derecho del operador de asignación. En el
segundo caso, el segundo elemento del arreglo en el índice [1] se reemplaza por la suma del
tercero y cuarto elementos del arreglo en los índices [2] y [3] De nuevo, el tercero y cuarto
elementos del arreglo no se afectan por esta operación, porque aparecen del lado derecho del
operador de asignación.
ESCRITURA DE ELEMENTOS DEL ARREGLO
Los objetos cout se usan para mostrar los elementos del arreglo. Usemos el mismo
arreglo para demostrar cómo escribir elementos del arreglo. Aquí está de nuevo la definición del
arreglo:
const int MAX = 10;
int muestra[MAX];
¿Qué se supone que harán los siguientes enunciados?
cout

MIGUEL Á. TOLEDO MARTÍNEZ
// MUESTRA UN ARREGLO CON UN CICLO for
#include // Para cin y cout
// ENUNCIA EL TAMAÑO DEL ARREGLO
const int MAX = 10;
void main(void)
{
int muestra[MAX]; // DEFINE UN ARREGLO ENTERO
for(int i = 0; i < MAX; ++i)
muestra[i] = i * i;
for (int i = 0; i < MAX; ++i)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
A continuación se darán varios ejemplos en los que se utilicen los conocimientos antes
adquiridos.
Ejemplo 18.2
El siguiente programa, INICIALIZA.CPP, utiliza una estructura de repetición for para inicializar a cero los
elementos de un arreglo de enteros llamado arreglo de diez elementos; luego imprime dicho arreglo en
formato de tabla.
/* El siguiente programa: INICIALIZA.CPP, inicializa a ceros a un arreglo de 10 elementos,
posteriormente imprime el contenido de dicho arreglo.
*/
#include //Para cout y cin
#include //Para setw()
void main(void)
{
Ejemplo 18.3
}//Fin de main()
int i, arreglo[10];
for(i = 0; i < 10; i++)
arreglo[i] = 0; //Inicializa el arreglo
cout

MIGUEL Á. TOLEDO MARTÍNEZ
que explícitamente inicializa a cero el primer elemento e implícitamente inicializa a cero a los otros nueve
elementos, pues hay menos valores que elementos en el arreglo. Recuerde que los arreglos automáticos no
se inicializan implícitamente a cero. El programador debe inicializar a cero cuando menos el primer
elemento para que los demás se inicialicen a cero de manera automática.
La siguiente declaración de arreglo:
int arreglo[5] = {32, 27, 64, 18, 95, 14};
provocaría un error de sintaxis, pues hay 6 inicializadores y únicamente 5 elementos en el arreglo.
Si se omite el tamaño del arreglo en la declaración por medio de una lista de inicio, el numero de elementos
del arreglo será el número de elementos de dicha lista. Por ejemplo:
Ejemplo 18.4
creará un arreglo de cinco elementos.
int arreglo[] = {1, 2, 3, 4, 5};
El siguiente programa, ELEMENTS.CPP, inicializa el arreglo llamado calificaciones y luego visualiza sus
elementos.
/* El siguiente programa: ELEMENTS.CPP, inicializa el arreglo calificaciones y
luego visualiza sus elementos.
*/
#include //Para cout y cin
void main(void)
{
Ejemplo 18.5
int calificaciones[5] = {80, 70, 90, 85, 80};
cout

MIGUEL Á. TOLEDO MARTÍNEZ
void main(void)
{
Ejemplo 18.6
Ejemplo 18.7
int calificaciones[5] = {80, 70, 90, 85, 80};
int i;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.8
El siguiente programa, PARES.CPP, inicializa los elementos de un arreglo llamado arreglo de diez
elementos a los enteros 2, 4, 6, ... , 20, e imprime el arreglo en formato de tabla. Estos números se generan
multiplicando por 2 cada valor consecutivo del contador del ciclo y sumándole 2.
/* Este programa: PARES.CPP inicializa un arreglo con los enteros pares comprendidos
entre 2 y 20 inclusive.
*/
#include //Para cout y cin
#include //Para setw()
void main(void)
{
Ejemplo 18.9
const int TAMANO_ARREGLO = 10;
int j, arreglo[TAMANO_ARREGLO];
for(j = 0; j < TAMANO_ARREGLO;j++) //Inicializa arreglo
arreglo[j] = 2 + 2 * j;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.10
El siguiente programa, SUMAVALORES.CPP, suma los valores contenidos en el arreglo de enteros de
doce elementos.
/* El siguiente programa: SUMAVALORES.CPP, Calcula la suma de los elementos de un arreglo. */
#include //Para cout y cin
void main(void)
{
Ejemplo 18.11
const int TAMANO_ARREGLO = 12;
int arreglo[TAMANO_ARREGLO] = {1, 3, 5, 4, 7, 2, 99, 16, 45, 67, 89, 45};
int total = 0;
for(int i = 0; i < TAMANO_ARREGLO; i++)
total += arreglo[i];
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.12
El siguiente programa, PROMEDIO1.CPP, calcula el promedio de los elementos de un arreglo. Los
elementos del arreglo son preasignados.
/* El siguiente programa: PROMEDIO1.CPP, calcula el valor promedio de un arreglo.
Los elementos del arreglo están preasignados.
*/
#include //Para cout y cin
const int TAMANO_ARREGLO = 10;
void main(void)
{
Ejemplo 18.13
double arreglo[TAMANO_ARREGLO] = { 12.2, 45.4, 67.2, 12.2, 34.6, 87.4,
83.6, 12.3, 14.8, 55.5 };
double suma = 0;
for (int ix = 0; ix < TAMANO_ARREGLO; ++ix)
{
suma += arreglo[ix];
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.14
Nuestro siguiente programa, HISTOGRAMA.CPP, lee los números de un arreglo llamado arreglo y traza
la información en forma de un gráfico de barras o histograma; cada número se imprime, seguido de una
barra consistente en la misma cantidad de asteriscos.
/* El siguiente programa: HISTOGRAMA.CPP, imprime un histograma. */
#include //Para cout y cin
#include //Para setw()
void main(void)
{
}//Fin de main()
Ejemplo 18.15
// Ahora obtiene el promedio
double suma = 0;
for (int ix = 0; ix < numeroElementos; ++ix)
suma += arreglo[ix];
cout

MIGUEL Á. TOLEDO MARTÍNEZ
void main(void)
{
Ejemplo 18.16
El siguiente programa, CARACTERES.CPP, muestra la inicialización de un arreglo de caracteres con una
literal de cadena; la lectura de una cadena para dejarla en un arreglo de caracteres; la impresión de un
arreglo de caracteres como cadena y el acceso a los caracteres individuales de una cadena.
Ejemplo 18.17
const int TAMANO_ARREGLO = 7;
int cara, frecuencia[TAMANO_ARREGLO] = {0};
srand(time(0));
for(int tirada = 1; tirada

MIGUEL Á. TOLEDO MARTÍNEZ
/* El siguiente programa: ESTAUTO.CPP, ilustra el uso de arreglos estáticos y automáticos. */
#include //Para cout y cin
void arregloEstatico(void);
void arregloAutomatico(void);
void main(void)
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
PASO DE ARREGLOS Y ELEMENTOS DE ARREGLOS A LAS FUNCIONES
Es posible pasar un arreglo completo a una función o pasar sólo elementos de un arreglo a
una función. Lo importante de recordar es que para pasar un arreglo completo, deberá pasar la
dirección del arreglo. En C y C++, el nombre del arreglo es la dirección del primer elemento
(índice[0]) del arreglo. Empecemos viendo el encabezado de la función. Éste es el prototipo para
pasar un arreglo unidimensional a una función:
void raro(char arreglo[TAMANO_ARREGLO]);
o lo que es más correcto
void raro(char arreglo[], int tamanoArreglo);
Observe el prototipo, vea que la función no regresa un valor. Hay un parámetro de
caracteres llamado arreglo[TAMANO_ARREGLO] La única serie de corchetes después del
identificador del parámetro implica que el parámetro es un arreglo unidimensional con un
tamaño TAMANO_ARREGLO. Cuando se pasan los arreglos a una función, la función deberá
saber qué tan grande es el arreglo que aceptará. Ahora, el identificador del arreglo hace
referencia a la dirección del arreglo, así el arreglo pasa por referencia a la función. De esta
manera, cualquier operación en el arreglo dentro de la función afectará el contenido original del
arreglo en el programa llamador. Asimismo, dado que el parámetro es la dirección del arreglo, no
se requiere ningún símbolo ampersand, (&), para pasar el arreglo por referencia. De hecho, el
uso de un símbolo ampersand antes del parámetro del arreglo originará un error de compilación.
Después, para llamar esta función y pasar el arreglo, simplemente utilice el siguiente
enunciado:
raro(nombreArreglo);
o lo que es más correcto
raro(nombreArreglo, tamanoArreglo);
Desde luego, esta llamada supone que nombreArreglo es la denominación del arreglo en
el programa llamador. (Recuerde que el identificador del argumento real y el identificador del
parámetro formal pueden ser diferentes.) La llamada a nombreArreglo da referencia de la
dirección del arreglo, de manera que, la dirección del arreglo pasa a la función más que una
copia del arreglo. Así, cualquier operación en el arreglo dentro de la función afectará los
elementos originales del arreglo. Un programa completo es como sigue:
Ejemplo 18.18
/* El siguiente programa: PASARRE.CPP, ilustra como se pasa un arreglo a una función. */
#include // Para cin y cout
// DECLARA EL TAMAÑO DEL ARREGLO
const int TAMANO_ARREGLO = 3;
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-21

MIGUEL Á. TOLEDO MARTÍNEZ
// FUNCIÓN PROTOTIPO
void raro(char arreglo[TAMANO_ARREGLO]);
void main(void)
{
//DEFINE UN ARREGLO DE CARACTERES
char nombre[TAMANO_ARREGLO];
//LLENE EL ARREGLO nombre CON CARACTERES
nombre[0] ='I';
nombre[1] ='B';
nombre[2] ='M';
//MUESTRA EL ARREGLO nombre
cout

MIGUEL Á. TOLEDO MARTÍNEZ
void pasaPorValor(int elementoArreglo);
El encabezado dice que la función no regresa ningún valor y espera recibir un valor entero desde el
programa llamador. Suponga que se hace un llamado a la función como sigue:
pasaPorValor(registros[0]);
Observe que el argumento real en la llamada de la función es registros[0] Esto genera una copia del
elemento almacenado en el índice [0] en el arreglo registros[] que será transferido a la función por valor.
Como resultado, cualquier operación en este elemento dentro de la función no afectará el valor del
elemento en el arreglo registros[] original. Si quiere que el elemento manifieste algún cambio dentro de la
función, deberá pasarla por referencia usando el símbolo ampersand en la función prototipo, como ésta:
void pasaPorReferencia(int &elementoArreglo);
Ahora, cualquier llamada a la función pasará la dirección del elemento a la función, pasando de esta manera
el elemento por referencia.
Ejemplo 18.19
El siguiente programa muestra cómo los elementos de un arreglo pasan por valor o por referencia.
/* El siguiente programa: PASVALREF.CPP, ilustra el uso de paso de elementos de un arreglo por
valor y por referencia.
*/
#include // Para cin y cout
//ENUNCIA EL TAMAÑO DEL ARREGLO
const int TAMANO_ARREGLO = 3;
//FUNCIONES PROTOTIPO
void pasaPorValor(int elementoArreglo);
void pasaPorReferencia(int &elementoArreglo);
void main(void)
{
int registros[TAMANO_ARREGLO];
registros[0] = 10;
registros[1] = 20;
registros[2] = 30;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
void pasaPorValor(int elementoArreglo)
{
++elementoArreglo;
} // Final de pasaPorValor()
void pasaPorReferencia(int &elementoArreglo)
{
++elementoArreglo;
} // Final de pasaPorReferencia()
La salida que produce el programa manifiesta el efecto de las dos funciones en el elemento del arreglo.
El valor del elemento en registro[0] antes de pasaPorValor() es : 10
El valor del elemento en registro[0] después de pasaPorValor() es : 10
El valor del elemento en registro[0] antes de pasaPorReferencia() : 10
El valor del elemento en registro[0] después de pasaPorReferencia(): 11
Estudie los dos programas siguientes para asegurarse que comprende cómo pasan a las
funciones los arreglos completos y los elementos individuales del arreglo.
Ejemplo 18.20
El siguiente programa, PASOARRE2.CPP, muestra la diferencia entre pasar un arreglo completo y pasar
un elemento del arreglo.
/* El siguiente programa: PASOARRE2.CPP, pasa un arreglo y elementos del arreglo a funciones. */
#include //Para cout y cin
#include //Para setw()
void modificarArreglo(int[], int);
void modificarElemento(int);
void main(void)
{
const int TAMANO_ARREGLO = 5;
int i, arreglo[TAMANO_ARREGLO] = {0, 1, 2, 3, 4};
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.21
Ejemplo 18.22
cout

MIGUEL Á. TOLEDO MARTÍNEZ
/* El siguiente programa: ARRPARAM.CPP, pasa tres arreglos diferentes (de diferentes tamaños)
a la función mostrarValores().
*/
#include //Para cout y cin
void mostrarValores(int valores[], int numeroElementos)
{
int i;
void main(void)
{
Ejemplo 18.23
cout

MIGUEL Á. TOLEDO MARTÍNEZ
int buscaMinimo(int arreglo[], int tamano)
{
int pequeno = arreglo[0];
Ejemplo 18.24
for (int i = 1; i < tamano; i++)
if (arreglo[i] < pequeno)
pequeno = arreglo[i];
return pequeno;
}//Fin de buscaMinimo()
int buscaMaximo(int arreglo[], int tamano)
{
int grande = arreglo[0];
void main(void)
{
for (int i = 1; i < tamano; i++)
if (arreglo[i] > grande)
grande = arreglo[i];
return grande;
}//Fin de buscaMaximo()
int arreglo[MAX], numElementos;
numElementos = obtenNumPuntos(MIN, MAX);
// Pide datos al usuario
for (int i = 0; i < numElementos; i++)
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Función obtenerCalificaciones(): Obtiene del usuario los registros de los exámenes y los
coloca en un arreglo.
Acepta: El número de calificaciones y el arreglo de las
calificaciones con un tamaño máximo de MAX.
Regresa: El número de calificaciones y el arreglo que llena el
usuario con las calificaciones.
Es necesario que la interfaz de la función acepte y regrese la estructura del arreglo. Supongamos que las
calificaciones son valores decimales y, por lo tanto, se necesita un arreglo de punto flotante. La función
prototipo será:
void obtenerCalificaciones(int &numero, float calificaciones[MAX])
A partir de esto, es fácil la escritura de la función. Emplearemos un enunciado cin dentro de un ciclo for en
el cuerpo de la función para llenar el arreglo con las calificaciones.
A continuación la función completa:
void obtenerCalificaciones(int &numero, float calificaciones[MAX])
{
cout > numero;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
El cuerpo de la función simplemente suma todas las calificaciones del arreglo y los divide entre su número.
A continuación se ve la función completa:
float promedio(int numero, float calificaciones[MAX])
{
float total = 0.0;
for (int i = 0; i < numero; ++i)
total +=calificaciones[i];
return total/numero;
} // Fin de promedio()
Hay dos variables locales de función definidas: total e i. total actuará como una variable temporal para
acumular la suma de las calificaciones y la variable i es la variable contador del ciclo. Primero, la variable
total se inicializa a 0. Después se usa el ciclo para obtener los elementos del arreglo, uno por uno y
adicionarlos a total. Observe que el contador de ciclo (i) actúa como el índice del arreglo dentro del ciclo.
De esta manera se extraen los elementos del arreglo, desde el índice [0] hasta [numero – 1], en forma
secuencial con cada ciclo de iteración y se adicionan a total. La última calificación se localiza en el índice
[numero – 1]. Una vez que el ciclo calcula la suma total de todas las calificaciones, se usa un enunciado
return para regresar el promedio calculado.
Por último, la función mostrarResultado() mostrará las calificaciones individuales obtenidas del usuario
junto con sus promedios. Para hacer esto, el arreglo deberá pasar a la función para obtener las
calificaciones. Aquí está la descripción de la función:
Función mostrarResultado(): Muestra las calificaciones individuales y su
promedio.
Acepta: El número de calificaciones para mostrarlas en
pantalla y el arreglo de las calificaciones.
Regresa: Nada.
Para mostrar el promedio, sólo se llamará a la función promedio() dentro de esta función como parte de un
enunciado cout. La función completa entonces se convierte en:
void mostrarResultado(int numero, float calificaciones[MAX])
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
/* El siguiente programa: ARREGLOS.CPP muestra el uso de los arreglos. */
/*******************************************************************************
Este programa calculará un promedio de calificaciones desde registros escritos
por el usuario en un arreglo.
*******************************************************************************/
#include // Para cin y cout
// Constante global
const int MAX = 25; // Número máximo de registros.
// Funciones prototipo
void obtenerCalificaciones(int &numero, float calificaciones[MAX]);
float promedio(int numero, float registros[MAX]);
void mostrarResultados(int numero, float calificaciones[MAX]);
void main(void)
{
// Define la variable numero y el arreglo
int numero = 0; // Número de calificaciones
float calificaciones[MAX]; // Definición del arreglo
// LLama a las funciones para obtener las calificaciones y mostrar resultados
obtenerCalificaciones(numero, calificaciones);
mostrarResultados(numero, calificaciones);
} // Fin de main()
/*******************************************************************************
Esta función obtiene los registros del usuario y los coloca en el arreglo
calificaciones.
*******************************************************************************/
void obtenerCalificaciones(int &numero, float calificaciones[MAX])
{
cout numero;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
/*******************************************************************************
Esta función muestra las calificaciones del arreglo y el promedio final.
*******************************************************************************/
void mostrarResultados(int numero, float calificaciones[MAX])
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.26
El siguiente programa, BURBUJA1.CPP, ordena los valores del arreglo de diez elementos arreglo en
orden ascendente. La técnica de la que nos valemos se llama ordenamiento de burbuja u ordenamiento
por hundimiento(dependiendo si se ordena en orden descendente o ascendente), pues los valores más
pequeños gradualmente burbujean hacia la parte alta del arreglo como las burbujas de aire que ascienden en
el agua, mientras que los valores más grandes se hunden al fondo del arreglo. La técnica es pasar varias
veces por el arreglo. En cada pasada, se comparan pares sucesivos de elementos. Si uno de los pares está en
orden ascendente (o son idénticos los valores), se queda tal cual. Si está en orden descendente, se
intercambian sus valores en el arreglo.
/* El siguiente programa: BURBUJA1.CPP, ordena los valores de un arreglo en orden ascendente
utilizando el método de la burbuja.
*/
#include //Para cout y cin
#include //Para setw()
void main(void)
{
const int TAMANO_ARREGLO = 10;
int arreglo[TAMANO_ARREGLO] = {2, 6, 4, 8, 10, 12, 89, 68, 45, 37};
int i, temporal;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.27
El problema anterior puede mejorarse solicitando el número de datos a ordenar, llamaremos a este programa,
BURBUJA2.CPP. Es importante que observe algunos cambios que hicimos en la función clasifBurbuja()
/* El siguiente programa: BURBUJA2.CPP, ordena arreglos usando el método de ordenamiento
de la burbuja.
*/
#include //Para cout y cin
const int MIN = 2;
const int MAX = 10;
int obtenNumPuntos(int minimo, int maximo)
{
int numPuntos;
do
return numPuntos;
}//Fin de obtenNumPuntos()
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
void main(void)
{
Ejemplo 18.28
}//Fin de clasifBurbuja()
int arr[MAX];
int numElementos;
{
int temp = intArr[i];
intArr[i] = intArr[j];
intArr[j] = temp;
}//Fin de for
numElementos = obtenNumPuntos(MIN, MAX);
entradaArreglo(arr, numElementos);
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.29
El método de la burbuja, puede mejorarse disminuyendo el número de elementos en cada pasada, a este método se
le conoce con el nombre de selección. El siguiente programa, SELECCIÓN.CPP, ilustra este método.
Ejemplo 18.30
metodoBurbuja(valores, 30);
for (i = 0; i < 30; i++)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
/* El siguiente programa: METSHELL.CPP, utiliza el método Shell para ordenar
un arreglo que contiene 50 elementos generados aleatoriamente.
*/
#include //Para cout y cin
#include //Para rand()
void ordenarShell(int arreglo[], int tamano)
{
int temp, espacio, i, banderaCambio;
Ejemplo 18.31
espacio = tamano / 2;
do
{
do
{
banderaCambio = 0;
for (i = 0; i < tamano - espacio; i++)
if (arreglo[i] > arreglo[i + espacio])
{
temp = arreglo[i];
arreglo[i] = arreglo[i + espacio];
arreglo[i + espacio] = temp;
banderaCambio = 1;
}//Fin de if
} while (banderaCambio);
} while (espacio = espacio / 2);
}//Fin de ordenarShell()
void main(void)
{
int valores[50], i;
for(i = 0; i < 50; i++)
valores[i] = rand() % 100;
ordenarShell(valores, 50);
for (i= 0; i < 50; i++)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
/* El siguiente programa: RAPIDO.CPP, utiliza el método de clasificación ordenamiento
rápido, para ordenar un arreglo que contiene 100 elementos generados en forma
aleatoria.
*/
#include //Para cout y cin
#include //Para rand()
void ordenarRapido(int arreglo[], int primero, int ultimo)
{
int temp, bajo, alto, separadorLista;
do
Ejemplo 18.32
bajo = primero;
alto = ultimo;
separadorLista = arreglo[(primero + ultimo) / 2];
{
while (arreglo[bajo] < separadorLista)
bajo++;
while (arreglo[alto] > separadorLista)
alto--;
if (bajo

MIGUEL Á. TOLEDO MARTÍNEZ
Cada una de las respuestas es un número del 1 al 9. El programa calcula la media, la mediana y la moda de
los 99 valores.
/* El siguiente programa: ESTADISTICA.CPP, presenta el tema del análisis de información
de una encuesta. Calcula la media, la mediana y la moda de los datos.
*/
#include //Para cout y cin
#include //Para setw(w)
void media(const int [], int);
void mediana(int [], int);
void moda(int [], int [], int);
void burbuja(int [], int);
void escribirArreglo(const int[], int);
void main(void)
{
const int TAMANO_RESPUESTAS = 99;
int frecuencia[10] = {0},
respuestas[TAMANO_RESPUESTAS] = {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};
media(respuestas, TAMANO_RESPUESTAS);
mediana(respuestas, TAMANO_RESPUESTAS);
moda(frecuencia, respuestas, TAMANO_RESPUESTAS);
}//Fin de main()
void media(const int contestacion[], int tamanoArreglo)
{
int total = 0;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
escribirArreglo(contestacion, tamano);
burbuja(contestacion, tamano);
cout

MIGUEL Á. TOLEDO MARTÍNEZ
a[j] = a[j + 1];
a[j + 1] = temporal;
}//Fin de if
}//Fin de burbuja()
void escribirArreglo(const int a[], int tamano)
{
for(int j = 0; j < tamano; j++)
{
if(j %20 == 0)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
/* El siguiente programa: BUSLINEAL.CPP, ilustra el método de búsqueda lineal en un arreglo. */
#include //Para cout y cin
int busquedaLineal(const int[], int, int);
void main(void)
{
const int TAMANO_ARREGLO = 100;
int a[TAMANO_ARREGLO], claveBusqueda, elemento;
for(int x = 0; x < TAMANO_ARREGLO; x++) //Crea algunos datos
a[x] = 2 * x;
cout > claveBusqueda;
elemento = busquedaLineal(a, claveBusqueda, TAMANO_ARREGLO);
if(elemento != -1)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
búsqueda binaria de cualquier arreglo ordenado puede determinarse encontrando la primera potencia de 2
mayor que el número de elementos del arreglo.
Ejemplo 18.34
El siguiente programa, BUSBIN.CPP, presenta la versión iterativa de la función busquedaBinaria() La
función recibe cuatro argumentos: un arreglo de enteros b, un entero claveBusqueda, el índice bajo del
arreglo y el índice alto del arreglo. Si la clave de búsqueda no es igual al elemento de la mitad de un
subarreglo, se ajusta el índice bajo o alto para poder hacer la búsqueda en un subarreglo más pequeño. Si la
clave de búsqueda es menor que el elemento central, el índice alto se establece a mitad – 1 y se continúa la
búsqueda en los elementos de bajo a mitad – 1. Si la clave de búsqueda es mayor que el elemento central, el
índice bajo se establece a mitad + 1 y se continúa la búsqueda en los elementos de mitad + 1 a alto. El
programa emplea un arreglo de 15 elementos. La primera potencia de 2 mayor que la cantidad de elementos
de este arreglo es 16 (2 4 ), por lo que se necesitan un máximo de 4 comparaciones para encontrar la clave de
búsqueda. La función imprimirEncabezado() envía a la salida los índices del arreglo y la función
imprimirFila() envía a la salida cada subarreglo generado durante el proceso de búsqueda binaria. El
elemento central de cada subarreglo se marca con un asterisco (*), para indicar el elemento con el que se
compara la clave de búsqueda.
/* El siguiente programa: BUSBIN.CPP, ilustra el uso de la búsqueda binaria en un arreglo. */
#include //Para cout y cin
#include //Para setw()
int busquedaBinaria(int[], int, int, int, int);
void imprimirEncabezado(int);
void imprimirFila(int[], int, int, int, int);
void main(void)
{
const int TAMANO_ARREGLO = 15;
int a[TAMANO_ARREGLO], clave, resultado;
for(int i = 0; i < TAMANO_ARREGLO; i++)
a[i] = 2 * i; //Crea los elementos del arreglo
cout > clave;
imprimirEncabezado(TAMANO_ARREGLO);
resultado = busquedaBinaria(a, clave, 0, TAMANO_ARREGLO - 1, TAMANO_ARREGLO);
if(resultado != -1)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.35
{
mitad = (bajo + alto) / 2;
imprimirFila(b, bajo, mitad, alto, tamano);
if(claveBusqueda == b[mitad]) //coincidencia
return mitad;
else if(claveBusqueda < b[mitad])
alto = mitad - 1; //Busca en la parte baja del arreglo
else
bajo = mitad + 1; //Busca en la parte alta del arreglo
}//Fin de while
return -1; //No se encontró claveBusqueda
}//Fin de busquedaBinaria()
//Imprime el encabezado para la salida
void imprimirEncabezado(int tamano)
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
/* El siguiente programa: BINARIO.CPP, utiliza una búsqueda binaria para localizar
valores en el arreglo llamado contador, el cual contiene los valores de 1 a
100. La función busquedaBinaria imprime mensajes que describen el proceso.
*/
#include //Para cout y cin
int busquedaBinaria(int arreglo[], int valor, int tamano)
{
int encontrado = 0;
int alto = tamano, bajo = 0, enmedio;
void main(void)
{
enmedio = (alto + bajo) / 2;
cout

MIGUEL Á. TOLEDO MARTÍNEZ
SOLUCIÓN DE PROBLEMAS EN ACCIÓN: Búsqueda en un arreglo con iteración
(Búsqueda secuencial)
PROBLEMA
Diversas aplicaciones requieren de un programa para buscar un determinado elemento en un arreglo. Para
realizar esta tarea se usan dos algoritmos comunes que son búsqueda secuencial o serial y búsqueda
binaria. Por lo común, la búsqueda secuencial se utiliza para arreglos no ordenados y la búsqueda binaria
en arreglos ordenados. En el siguiente problema veremos la búsqueda secuencial; en un problema posterior
veremos la búsqueda binaria.
Desarrolle una función que busque, en forma secuencial, en un arreglo de enteros, el valor de un elemento
dado y que regrese el índice del elemento si éste se encuentra en el arreglo.
DEFINICIÓN DEL PROBLEMA
Debido a que se trata de una función, la definición del problema se enfocará a la interfaz de la función. Por
consiguiente, se debe considerar que la función aceptará y regresará algo. Llamaremos a la función
busquedaSec() A partir del enunciado del problema, la función deberá buscar en un arreglo de enteros un
valor de un elemento determinado. De esta manera, la función necesita dos cosas para realizar este trabajo:
(1) el arreglo y (2) el elemento que se va a buscar. Estos serán los parámetros de la función, ¿deberán ser
de valor o de referencia? Bueno, la función no cambiará ni al arreglo ni al elemento a buscar, ¿es
correcto? Por lo tanto, los parámetros serán por valor.
Después, necesitamos determinar que va a regresar la función al programa llamador. A partir del enunciado
del problema, se observa que la función necesita regresar el índice del elemento buscado, si se encuentra en
el arreglo. En C++ todos los índices de los arreglos son enteros, por lo tanto la función regresará un valor
entero. Pero, ¿qué pasa si el elemento que se busca no se encuentra en el arreglo? Se regresará algún
valor entero que aclare esta situación. Dado que, en C++ los índices de los arreglos se encuentran en un
rango de 0 a algún entero positivo finito, si el elemento no se encuentra en el arreglo, regresará el entero -1.
De esta manera usaremos –1 para indicar la condición no encontrado, porque en C++ ningún índice de
arreglo tiene este valor. La descripción de la interfaz de la función será:
Función busquedaSec(): Busca en un arreglo entero un valor de elemento
dado.
Acepta: Un arreglo de enteros y el elemento que se busca.
Regresa: El índice del arreglo del elemento, si se encuentra, o
el valor –1 si no se encuentra el elemento.
La descripción de interfaz de la función anterior proporciona toda la información necesaria para escribir la
interfaz de la función, como sigue:
int busquedaSec(int arreglo[MAX], int elemento)
La interfaz indica que la función aceptará dos cosas: (1) un arreglo de elementos enteros MAX y (2) un
valor entero, llamado elemento, que será el valor que se busca.
La siguiente tarea es desarrollar el algoritmo de búsqueda secuencial.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-45

MIGUEL Á. TOLEDO MARTÍNEZ
PLANEACIÓN DE LA SOLUCIÓN
¿Qué quiere decir exactamente búsqueda secuencial? Rastreo en el arreglo en forma secuencial, de un
elemento al siguiente, empezando en la primera posición del arreglo y deteniéndose al encontrar el
elemento o al llegar al final del arreglo. De esta manera, el algoritmo deberá verificar el elemento
almacenado en la primera posición del arreglo, después en la segunda posición del arreglo, enseguida en la
tercera y así sucesivamente, hasta que encuentre el elemento o hasta que se agoten los elementos del
arreglo. Desde luego, ésta es una tarea repetitiva de verificación de un elemento en el arreglo, luego
moverse al siguiente elemento y verificar otra vez y así sucesivamente. Considere el siguiente algoritmo
que emplea un ciclo while para realizar la operación de verificación repetitiva:
Algoritmo busquedaSec()
busquedaSec()
INICIO
encuentra = falso.
indice = primer índice del arreglo.
while(elemento no se Encuentra) AND (Indice

MIGUEL Á. TOLEDO MARTÍNEZ
// Busca en el arreglo hasta encontrar o alcanzar el final del arreglo
while((!encuentra) && (i < MAX))
{
if (a[i] == elemento) // Verifica el elemento del arreglo
encuentra = Verdadero; // Si es igual, establece
else // encuentra a Verdadero
++i;
} // Fin del while
// Si se encuentra el elemento, regresa la posición del elemento en el arreglo
// Si no regresa –1
if(encuentra)
return i;
else
return –1;
} // Fin de busquedaSec()
No debe haber sorpresas en este código. En la parte superior de la función, verá el encabezado que es
idéntico a la interfaz de la función desarrollada anteriormente. Después verá una clase de datos enumerada
creada para definir Falso y Verdadero. Recuerde que los valores predeterminados para elementos de datos
enumerados son enteros, empezando con 0. De esta manera, Falso se define con el valor 0 y Verdadero se
define con el de 1. Esto permite la utilización de los identificadores Falso y Verdadero dentro del programa
para representar los valores enteros 0 y 1 respectivamente. Además, las verificaciones booleanas se pueden
hacer contra estos valores, porque C++ interpreta un 0 como un Falso lógico y 1 como un Verdadero
lógico.
La variable encuentra se define como un objeto de clases de datos booleanos enumerados y se establece a
Falso. Utilizaremos la variable i como variable índice del arreglo. Esta variable se define como un entero y
establece a 0 el primer índice del arreglo. Recuerde que los arreglos en C++ siempre empiezan con el índice
0. El ciclo while emplea el operador AND (&&) para verificar los valores de encuentra e i. El ciclo se
repetirá hasta que se encuentre el elemento (encuentra) y el valor de i sea menor que el tamaño MAX del
arreglo. Recuerde que cuando el tamaño del arreglo es MAX, el último índice del arreglo es MAX – 1. Por
lo tanto, cuando i excede el índice máximo del arreglo, MAX – 1, el ciclo se rompe. Cuando el ciclo se
rompe, el valor de encuentra se verifica. Si encuentra es Verdadero, se regresa el valor de i; si encuentra
es Falso, el valor –1 se regresa para indicar que el elemento no se encontró en el arreglo.
SOLUCIÓN DE PROBLEMAS EN ACCIÓN: Como ordenar un arreglo con iteración
(Ordenación por inserción)
PROBLEMA
Ordenar un arreglo significa colocar los elementos del arreglo en orden ascendente o descendente desde el
principio al final del arreglo. Hay muchos algoritmos comunes utilizados para ordenación. Hay
clasificación por inserción, clasificación por burbuja, clasificación por selección, clasificación rápida,
clasificación combinada y clasificación apilada, sólo por mencionar algunas. En un curso de estructura de
datos, es muy probable que aprenda y analice todos estos algoritmos de ordenación. En este problema se
desarrollará el algoritmo de clasificación por inserción y se codificará como una función en C++.
Desarrolle una función que se pueda llamar para ordenar un arreglo de caracteres en orden ascendente
utilizando el algoritmo clasificación por inserción.
DEFINICIÓN DEL PROBLEMA
De nuevo, codificaremos el algoritmo como una función C++, así la definición del problema se enfocará en
la interfaz de la función, guiándonos a la función prototipo. Llamaremos a la función clasifPorInser()
Piense que necesita clasifPorInser() para hacer un trabajo. Bueno, deberá recibir un arreglo de caracteres
no clasificados y regresar el mismo arreglo como un arreglo clasificado, ¿correcto? ¿Necesita algo más?
No, la función no requiere datos adicionales, porque lo único que se opera es el arreglo mismo.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-47

MIGUEL Á. TOLEDO MARTÍNEZ
¿Qué hay de los valores de regreso? ¿Necesita regresar la función un valor sencillo o una serie de
valores? La función no necesita regresar ningún valor sencillo, deberá regresar el arreglo ordenado. Por lo
tanto, la clase de valor regresado será void y el arreglo será un parámetro de referencia, ¿correcto?
Recuerde que cuando se pasan los arreglos a las funciones C++, siempre son tratados como parámetros de
referencia porque el nombre del arreglo representa una dirección en memoria. Por lo tanto, aquí está la
descripción de la interfaz de la función clasifPorInser():
Función clasifPorInser(): Clasifica un arreglo de caracteres en orden ascendente.
Acepta: Un arreglo de caracteres sin clasificar.
Regresa: Un arreglo de caracteres clasificados.
De la descripción anterior, la interfaz de la función se codifica fácilmente como:
void clasifPorInser(char arreglo[MAX])
La interfaz dice que clasifPorInser() recibirá un arreglo de caracteres de tamaño MAX. El tipo regresado es
void, porque no se regresa ningún valor sencillo. Sin embargo, debido a que el arreglo completo se pasa a la
función, cualquier operación de clasificación sobre el arreglo dentro de la función se reflejará en el
programa llamador.
PLANEACIÓN DE LA SOLUCIÓN
Antes de establecer el algoritmo, vamos a ver cómo trabaja la clasificación por inserción. Vea la figura
18.3. Suponga que vamos a clasificar un arreglo de 5 caracteres en orden ascendente. Antes de entrar en
detalle, vea la figura de arriba abajo y de izquierda a derecha. El arreglo sin ordenar se muestra en la parte
superior de la figura 18.3 y el arreglo ordenado se muestra en la parte inferior de la figura 18.3. Observe
que el sombreado se emplea en la figura para mostrar el proceso de clasificación de arriba a abajo.
Conforme procedemos desde el arreglo sin clasificar en la parte superior, el sombreado se incrementa,
mostrando la porción del arreglo que está clasificado, hasta que el arreglo completo está sombreado en la
parte inferior de la figura 18.3.
La secuencia descendente muestra que se harán cuatro pasos a lo largo del arreglo para obtener al arreglo
clasificado mostrado en la parte inferior de la figura. Con cada paso, un elemento se coloca dentro de su
posición clasificada relativa a los elementos que se encuentran antes en el arreglo. El primer paso empieza
con el primer elemento ‘E’, clasificado como se indica por medio del sombreado. Se considera que el
carácter individual ‘E’ se clasifica por sí mismo, porque no tiene ningún elemento antes que él. De esta
manera, la tarea en este primer paso es clasificar el segundo elemento, ‘D’, relativo al carácter ‘E’ que lo
precede.
El segundo paso empieza con los caracteres clasificados ‘D’ y ‘E’, como se indica por medio del
sombreado. La tarea en este paso es clasificar el tercer carácter, ‘C’, en relación con estos dos caracteres.
En el tercer paso se empieza con los caracteres clasificados ‘C’, ‘D’ y ‘E’, y la tarea es clasificar el carácter
‘B’ en relación con estos caracteres. Recuerde, en cada paso, la tarea es clasificar el primer carácter de la
parte no clasificada del arreglo en relación con los caracteres que le preceden. El proceso continúa hasta
que se clasifican todos los caracteres, como se muestra en la parte inferior de la figura 18.3. En cada paso
se repite prácticamente lo que se hizo en el paso anterior. Como resultado, es posible identificar un proceso
de repeticiones paso a paso, de arriba hacia debajo de la figura 18.3. Esta repetición dará origen a una
estructura de ciclo en nuestro algoritmo.
Ahora, la pregunta es: ¿qué sucede durante cada paso para clasificar finalmente al arreglo completo?
Bueno, durante cada paso, el primer elemento en la parte no clasificada (sin sombrear) del arreglo se
examina comparándolo a la secuencia clasificada de los elementos que le preceden. Si este elemento es
menor que el anterior, estos dos elementos se intercambian y de nuevo el elemento anterior se compara con
su predecesor, si es menor se intercambian y así sucesivamente.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-48

MIGUEL Á. TOLEDO MARTÍNEZ
Paso 1
Paso 2
[0] [1] [2] [3] [4]
[0] [1] [2] [3] [4] [0] [1] [2] [3] [4]
[0] [1] [2] [3] [4] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4]
CICLO EXTERNO
Paso 3
Paso 4
E D C B A
E D C B A D E C B A
D E C B A D C E B A
[0] [1] [2] [3] [4] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4]
[0] [1] [2] [3] [4] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4]
[0] [1] [2] [3] [4]
ARREGLO CLASIFICADO
C D E B A
C D E B A C D B E A C B D E A
CICLO INTERNO
B C D E A
B C D E A B C D A E B C A D E B A C D E A B C D E
A B C D E
Figura 18.3. La clasificación por inserción es un proceso de repeticiones anidadas
Este proceso se repite hasta que sucede una de dos cosas: (1) el elemento es mayor o igual a su predecesor,
o (2) el elemento está en la primera posición del arreglo (índice [0]) En otras palabras, el proceso de
comparación o intercambio de izquierda a derecha que se muestra en la figura 18.3 termina cuando el
elemento examinado se ha insertado en su posición adecuada en la parte clasificada del arreglo. Este
proceso de comparación o intercambio que representa la repetición de izquierda a derecha en la figura 18.3
dará como resultado otra estructura de ciclo en nuestro algoritmo. Por lo tanto, es posible identificar dos
procesos repetitivos en la figura 18.3, uno de arriba hacia abajo y otro de izquierda a derecha. ¿Cómo se
relacionan los dos procesos repetitivos? Bien, parece que por cada paso de arriba abajo a través del
arreglo, el proceso de comparación o intercambio se ejecuta de izquierda a derecha. De esta manera, el
proceso de izquierda a derecha deberá anidarse dentro del proceso de arriba abajo. Esto se reflejará en
nuestro algoritmo por medio de dos estructuras de ciclo: una controla el proceso de comparación o
intercambio de izquierda a derecha que deberá anidarse dentro del segundo ciclo que controla el proceso de
arriba abajo. Observe de nuevo la figura 18.3 para asegurarse que ve esta repetición anidada. Ahora que
tiene una idea de cómo funciona la ordenación por inserción, analice el algoritmo formal:
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-49

MIGUEL Á. TOLEDO MARTÍNEZ
Algoritmo clasifPorInser()
clasifPorInser()
INICIO
Establece i = segundo índice del arreglo.
mientras(i primer índice del arreglo) AND (A[j] < A[j – 1]))
Inicio
Intercambia A[j] y A[j – 1].
Decrementa j.
Fin.
Incrementa i.
Fin.
FIN.
La variable i controla el ciclo externo y j controla el ciclo interno. Observe que i empieza en el segundo
índice del arreglo. ¿Por qué no en el primer índice del arreglo? Porque el primer elemento en el arreglo
se clasifica siempre relativo a cualquier elemento precedente, ¿correcto? Por lo tanto, el primer paso
comienza con el segundo elemento del arreglo. El primer enunciado en el ciclo externo establece a j = i. De
esta manera, i y j localizan el primer elemento en la parte no clasificada del arreglo al principio de cada
paso. Ahora, el ciclo interno intercambiará al elemento localizado por j, el cual es A[j], con su elemento
predecesor, el cual es A[j – 1], siempre y cuando j sea mayor que el primer índice del arreglo y el elemento
A[j] sea menor que el elemento A[j – 1] Una vez que se hace el intercambio, se decrementa j. Esto obliga a
j a seguir siendo el elemento insertado dentro de la parte del arreglo ordenado. El intercambio continúa
hasta que no hay ningún elemento que preceda al elemento A[j] que sea menor que el A[j]
Una vez que se rompe el ciclo interno, el elemento A[j] se inserta en su posición correcta con relación con
los elementos que le preceden. Después, se hace otro paso incrementando la variable externa para el control
del ciclo i, estableciendo j a i, y ejecutando de nuevo el ciclo interno. Este proceso de ciclo anidado
continúa hasta que i se incrementa más allá de la última posición del arreglo.
Estudie el algoritmo anterior y compárelo con la figura 18.3 hasta que esté seguro que comprende
clasifPorInser() A continuación el código en C++.
CODIFICACIÓN DEL PROBLEMA
Hemos desarrollado la interfaz de la función clasifPorInser() En C++, el algoritmo se codifica fácilmente
como una función semejante a ésta:
// Función de intercambio()
void interCambio(char &x, char &y)
{
char temp; // Crea una variable temporal
temp = x;
x = y;
y = temp;
} // Fin de interCambio()
// Función clasificación por inserción
void clasifPorInser(char A[MAX])
{
int i; // Variable que controla el ciclo exterior
int j; // Variable que controla el ciclo interior
i = 1; // Establece i al índice del segundo elemento
while(i < MAX)
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-50

MIGUEL Á. TOLEDO MARTÍNEZ
{
j = i; // Localiza el primer elemento del arreglo no clasificado
while((j > 0) && (A[j] < A[j – 1]))
{
interCambio(A[j], A[j – 1]);
--j; // Hace que j siga al elemento insertado
} // Final del while interno
++i; // Hace que i localice el primer elemento de la parte no
clasificada.
} // Fin del while externo
} // Fin de clasifPorInser()
En este caso se pueden ver dos funciones codificadas en C++. Recuerde que el algoritmo clasifPorInser()
requiere una operación de intercambio. Para llevar a cabo esta tarea se ha codificado una función llamada
interCambio() Observe que esta función tiene dos parámetros de referencia que son caracteres. De esta
manera, la función recibe dos caracteres que se intercambian utilizando la variable local temporal (temp)
dentro de la función. Los caracteres de intercambio se envían de regreso al programa llamador por medio de
los parámetros de referencia. Desde luego, el programa llamador será la función clasifPorInser()
El código de clasifPorInser() debe ser directo a partir del algoritmo que se analizó. Estudie el código y
compárelo con el algoritmo. Encontrará que son idénticos desde un punto de vista lógico y estructural.
Debe notar cómo se llama a la función intercambio() dentro de clasifPorInser() Los elementos del arreglo
A[j] y A[j – 1] se pasan a la función. Estos elementos son caracteres sencillos, ¿correcto? Por lo tanto, la
función recibe dos caracteres y los intercambia. Los caracteres respectivos en el arreglo reflejan la
operación de intercambio, porque intercambio() emplea parámetros de referencia.
SOLUCIÓN DE PROBLEMAS EN ACCIÓN: Búsqueda en un arreglo con recursión
(Búsqueda binaria)
PROBLEMA
En este problema desarrollaremos otro popular algoritmo de búsqueda, llamado búsqueda binaria. El
algoritmo de búsqueda binaria que desarrollaremos empleará recursividad, aunque también se puede hacer
utilizando iteración. Una de las principales diferencias entre búsqueda binaria y búsqueda secuencial es que
la primera requiere que el arreglo se ordene antes de la búsqueda, mientras que la segunda no tiene este
requerimiento. Sin embargo, si va a empezar con un arreglo ordenado, la búsqueda binaria es mucho más
rápida que la secuencial, especialmente para arreglos grandes. Por ejemplo, si fuera a aplicar una búsqueda
secuencia a un arreglo de 1000 enteros, el algoritmo de búsqueda secuencial hará un promedio de 500
comparaciones para encontrar el elemento deseado. Peor aún, si el elemento deseado está en la última
posición del arreglo, la búsqueda secuencial hará mil comparaciones para encontrar el elemento. Por otra
parte, la búsqueda binaria requerirá un máximo de 10 comparaciones para encontrar el elemento, ¡aún si
está en la última posición del arreglo! Desde luego, se debe pagar un precio por esta mayor eficiencia. El
precio que se paga es un algoritmo más complejo. Por lo tanto, cuando busque en un arreglo ordenado, la
ventaja de la búsqueda secuencial es simplicidad, mientras que la ventaja de la búsqueda binaria es
eficiencia.
Desarrolle una función en C++ que se pueda llamar para buscar en un arreglo ordenado de enteros un
elemento con determinado valor y que regrese el índice del elemento si se encuentra en el arreglo. Utilice
una búsqueda binaria recursiva para realizar esta tarea.
Se desarrollará una función en C++, así la definición del problema se enfocará de nuevo a la interfaz de la
función. Sin embargo, antes de considerar la interfaz de la función, veamos cómo funciona una búsqueda
binaria recursiva, porque el algoritmo de búsqueda dictará los parámetros de la función. Por lo tanto,
primero trataremos el algoritmo y después desarrollaremos la interfaz de la función.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-51

MIGUEL Á. TOLEDO MARTÍNEZ
PLANEACIÓN DE LA SOLUCIÓN
La búsqueda binaria representa una operación recursiva natural. Recuerde que la idea detrás de la
recursividad es dividir un problema en subproblemas. Dividir un problema en subproblemas más simples de
exactamente el mismo tipo hasta que ocurra una condición primitiva. Esto no es lo mismo que el diseño de
software descendente, que divide los problemas en subproblemas más simples. La diferencia con la
recursividad es que los subproblemas son exactamente del mismo tipo de problema que el problema
original. Por ejemplo, suponga que está buscando un nombre en un directorio. Imagine que empieza al
principio del directorio y ve cada nombre hasta que encuentra el correcto. Esto es exactamente lo que hace
la búsqueda secuencial. ¿No sería más rápido, en promedio, abrir el directorio a la mitad? Después,
determinar qué mitad del directorio contiene el nombre que está buscando, dividir esta sección del
directorio a la mitad y así sucesivamente, hasta que obtiene la página en la cual aparece el nombre deseado.
Aquí está un algoritmo que describe la búsqueda en el directorio como se describió.
UN ALGORITMO DE BÚSQUEDA RECURSIVA EN UN DIRECTORIO
buscaTel()
INICIO
si(el directorio telefónico sólo tiene una página) entonces
Busca el nombre en la página.
sino
Abre el libro a la mitad.
si(el nombre está en la primera mitad) entonces
buscaTel(primera mitad del directorio para el nombre)
sino
buscaTel(segunda mitad del directorio para el nombre)
FIN.
¿Observa cómo esta búsqueda es recursiva? Se mantiene realizando las mismas operaciones básicas
hasta que llega a la página que contiene el nombre que está buscando. En otras palabras, la función
buscaTel() se mantiene llamándose a sí misma en el enunciado anidado si/sino hasta que se encuentra la
página correcta. La razón por la que se llama al proceso de búsqueda binaria es que deberá dividir el
directorio entre 2 (bi) cada vez que se llama a sí mismo el algoritmo.
Ahora, vamos a ver cómo se puede aplicar este proceso a la búsqueda en un arreglo de enteros. Se llamará a
la función de búsqueda binaria recursiva busquedaBin() y se desarrollará el algoritmo en varios pasos.
Aquí esta el primer nivel del algoritmo.
Algoritmo busquedaBin(): Primer nivel
busquedaBin()
INICIO
si(el arreglo tiene sólo un elemento) entonces
Determine si este elemento es el elemento buscado.
sino
Encuentre el punto medio del arreglo.
si(el elemento está en la primera mitad) entonces
busquedaBin(primera mitad)
sino
busquedaBin(segunda mitad)
FIN.
Observe cómo este algoritmo es casi idéntico al algoritmo buscaTel() Aquí el proceso de búsqueda se
continúa hasta que el arreglo se reduce a un elemento que se verifica contra el elemento que se está
buscando. ¿Observa cómo la búsqueda se mantiene llamándose a sí misma hasta que ocurre la
condición primitiva? Aunque este algoritmo proporciona una idea general de búsqueda binaria, se necesita
mayor detalle para codificar el algoritmo. Para hacerlo, debemos preguntarnos que datos necesita
busquedaBin() para realizar esta tarea. Bueno, al igual que la búsqueda secuencial, ésta necesita un arreglo
en dónde buscar y el elemento que se va a buscar ¿correcto? Sin embargo, la búsqueda secuencial trata con
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-52

MIGUEL Á. TOLEDO MARTÍNEZ
un tamaño de arreglo dado, mientras que la búsqueda binaria necesita tratar con arreglos de tamaños
diferentes conforme sigue dividiendo al arreglo original a la mitad. No solamente son estos arreglos de
diferente tamaño, sino el primero y el último índices de cada mitad son diferentes. Como resultado,
debemos proporcionar a busquedaBin() los límites del arreglo que está tratando en cualquier momento
dado. Esto se puede hacer pasando el primero y último índices del arreglo dado a la función. Llamemos a
estos índices primero y ultimo.
Estamos listos para escribir la descripción de la interfaz de la función:
Función busquedaBin(): Busca en un arreglo de enteros ordenado un valor
determinado.
Acepta: Un arreglo de enteros, un elemento de búsqueda, el primero
y el último índices del arreglo en el cual se busca.
Regresa: El índice del elemento, si se encuentra, o el valor -1 si el
elemento no se encuentra.
Esta descripción da suficiente información para escribir la interfaz de la función C++, como sigue:
int busquedaBin(int A[], int elemento, int primero, int ultimo)
Aquí, busquedaBin() regresará un valor entero que representa el índice del elemento que se busca. De
nuevo, verá que regresará el valor -1 si el elemento no se encuentra en el arreglo. La función recibe el
arreglo de enteros que se busca (A[]), el elemento que se busca (elemento), el primer índice del arreglo
(primero) y el último índice del arreglo (ultimo) Observe que ningún tamaño se proporciona para el arreglo
en que se busca porque la función buscará en forma recursiva en arreglos de diferentes tamaños.
El siguiente problema es determinar qué valor de primero y ultimo se utilizarán para cualquier arreglo
durante la búsqueda. Bueno, recuerde que se deberá dividir cualquier arreglo dado a la mitad para producir
dos nuevos arreglos cada vez que se hace una llamada recursiva busquedaBin() Dado cualquier arreglo
donde el primer índice es primero y el último índice es ultimo, se puede determinar el índice medio, como
sigue:
mitad = (primero + ultimo) / 2
Con este cálculo, la primera mitad del arreglo empieza en primero y finaliza en mitad - 1, y la segunda
mitad del arreglo empieza en mitad + 1 y finaliza en ultimo. Esta idea se muestra en la figura 18.4.
Pero, observe que ninguna mitad del arreglo contiene el elemento medio. Por me- dio de la utilización de
esta técnica, las dos mitades no hacen un todo, ¿correcto? Por lo tanto, antes que se haga la división,
suponga que verificamos el elemento medio para ver si es el elemento que se está buscando. La siguiente
verificación realiza el trabajo.
si (A[mitad] == elemento) entonces
regresar mitad.
Si esta verificación es verdadera antes de la división, se habrá encontrado el elemento que se está buscando
y es posible terminar las llamadas recursivas. De otra manera, el elemento almacenado en A[mitad] no es el
elemento que se está buscando, y esta posición del arreglo se puede ignorar durante el resto de la búsqueda.
Si éste es el caso, se dividirá el arreglo y continuará el proceso recursivo. Sin embargo, se tiene que
adicionar una segunda condición primitiva para el algoritmo recursivo. Aquí están las dos condiciones
primitivas que se han hecho:
1. El arreglo que se busca tiene sólo un elemento.
2. A [mitad] == elemento.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-53

MIGUEL Á. TOLEDO MARTÍNEZ
mitad = (primero + ultimo) / 2
[primero] [ultimo]
[primero] [mitad – 1] [mitad + 1] [ultimo]
Figura 18.4. La búsqueda binaria recursiva requiere que un arreglo sea dividido en mitades con cada llamada recursiva.
Cualquiera de estas condiciones primitivas hará que termine la llamada recursiva. Ahora, vamos a
considerar la primera condición primitiva más de cerca. ¿Cómo saber si el arreglo que se busca tiene
solamente un elemento? Bueno, conforme continúan las llamadas recursivas sin encontrar el elemento,
finalmente el arreglo se reducirá a un elemento sencillo. Si éste es el que se está buscando, la verificación si
A[mitad] == elemento será verdadera, y las llamadas recursivas se detendrán. Si no lo es, el valor de
primero se hará más grande que el valor de ultimo en la siguiente división. ¿Por qué? Porque si piensa en
la acción de división del algoritmo, se dará cuenta que cada llamada recursiva hace que primero se
incremento y ultimo se decremente. De esta manera, si el elemento no está en el arreglo, el valor de
primero se hace finalmente más grande que el valor de ultimo. Por lo tanto se puede usar esta idea para
verificar que el elemento no está en el arreglo, también para usarlo como una condición primitiva. De esta
manera, se reemplazará la condición primitiva original con el siguiente enunciado:
si (primero > ultimo) entonces
regresar – 1
Si ocurre esta condición, se regresa el valor -1, indicando que no se encontró el elemento y terminan las
llamadas recursivas.
Ahora, vamos a aplicar este conocimiento a un segundo nivel del algoritmo. Como sigue:
Algoritmo busquedaBin(): Segundo nivel
busquedaBin(A, elemento, primero, ultimo)
INICIO
si(primero > ultimo) entonces
regresar -1.
sino
Establecer mitad = (primero + ultimo) / 2.
si (A[mitad] == elemento) entonces
regresar mitad.
sino
si (el elemento está en la primera mitad) entonces
busquedaBin(A, elemento, primero, mitad - l)
sino
busquedaBin(A, elemento, mitad + 1, ultimo)
FIN.
Es evidente ahora que el algoritmo realiza la recursividad, porque se puede ver la función llamándose a sí
misma en uno o dos lugares, dependiendo de en qué mitad del arreglo dividido es probable que se encuentre
el elemento. También, observe en dónde se verifican los dos casos primitivos. Si, al inicio de una llamada
recursiva, primero > ultimo, el elemento no está en el arreglo y las llamadas recursivas terminan. Además,
si después de calcular mitad, se encuentra el elemento en A[mitad], terminará la llamada recursiva. En
ambos casos, la función ha terminado su ejecución y regresa un valor al programa llamador. Lo último que
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-54

MIGUEL Á. TOLEDO MARTÍNEZ
necesita el algoritmo es una forma para determinar si el elemento que se busca es muy probable que se
encuentre en la primera mitad o en la segunda mitad del arreglo dividido. Aquí es donde viene el
requerimiento para un arreglo ordenado. Si el arreglo está ordenado, es muy probable que el elemento se
encuentre en la primera mitad del arreglo cuando elemento < A[mitad]; de otra manera, es muy probable
que el elemento se encuentre en la segunda mitad del arreglo. Observe que usamos el término es muy
probable. Nosotros no podemos garantizar que el elemento se encuentre en cualquier mitad, ¡ya que,
inclusive, podría no estar en el arreglo! Todo lo que se puede hacer es dirigir la búsqueda a la mitad
donde es muy probable que se encuentre el elemento, dependiendo del orden de clasificación de los
elementos. Por lo tanto, se puede completar el algoritmo usando esta idea. Aquí está el algoritmo final:
Algoritmo busquedaBin()
busquedaBin(A, elemento, primero, ultimo)
INICIO
si(primero > ultimo) entonces
regresar -1.
sino
Establecer mitad = (primero + ultimo) / 2.
si (A[mitad] == elemento) entonces
regresar mitad.
sino
si (elemento < A[mitad]) entonces
busquedaBin(A, elemento, mitad - l).
sino
busquedaBin(A, elemento, mitad + 1, ultimo)
FIN.
Observe qué elegante es el algoritmo. Por elegante se debe entender que más que un proceso complicado
de búsqueda binaria, se trata de sólo unos cuantos enunciados. Se sabe que hay mucho por recorrer todavía,
pero la recursividad permite expresar todo este procedimiento en sólo unos cuantos enunciados. Como
puede ver, a menudo los algoritmos recursivos proporcionan soluciones simples a problemas de gran
complejidad, en donde una solución iterativa equivalente puede ser compleja. Éste no es siempre el caso,
porque algunas soluciones recursivas son relativamente poco prácticas para la eficiencia de velocidad y de
memoria. Recuerde la siguiente regla cuando considere la recursividad: considere una solución recursiva
para un problema sólo cuando no sea posible una solución iterativa sencilla. Tome en cuenta que la
búsqueda binaria tiene una solución iterativa relativamente sencilla. Se codificará esta solución para uno de
los problemas al final de esta lección.
CODIFICACIÓN DEL PROGRAMA
La función que requiere C++ ahora se puede codificar con facilidad a partir del algoritmo final. Como
sigue:
int busquedaBin(int[A], int elemento, int primero, int ultimo)
{
int mitad; // PUNTO MEDIO DEL ARREGLO
if (primero > ultimo) // SI EL ELEMENTO NO ESTÁ EN EL ARREGLO
return -l; // REGRESA -1, SI NO CONTINÚA LA BÚSQUEDA
else
{
mitad = (primero + ultimo) / 2; // ENCUENTRA EL PUNTO
// MEDIO DEL ARREGLO
if (elemento == A[mitad]) // Si EL ELEMENTO ESTÁ EN
// A[mitad]
return mitad; // REGRESA mitad
else // Si NO, BUSCA LA MITAD APROPIADA
if (elemento < A[mitad])
return busquedaBin(A, elemento, primero, mitad - l);
else
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-55

MIGUEL Á. TOLEDO MARTÍNEZ
return busquedaBin(A, elemento, mitad + 1, ultimo);
} / /FINAL DE else EXTERNO
} // FINAL DE busquedaBin()
No deberá tener ningún problema para comprender este código, ya que refleja la interfaz de la función y
al algoritmo que se desarrolló. Aquí la única diferencia es que las llamadas recursivas en busquedaBin()
forman parte de un enunciado return. Recuerde que C++ requiere que todos los caminos de ejecución de
una función sin void den origen a un enunciado return.
Ejemplo 18.36
El siguiente programa, BÚSQUEDA.CPP, ilustra los métodos de búsqueda lineal y binaria. Es bastante
interesante la solución que se propone, por lo que se le pide al lector que lea con detenimiento la
codificación.
/* El siguiente programa: BUSQUEDA.CPP, busca en arreglos usando los métodos de búsqueda lineal
y binaria.
*/
#include
#include
#include
typedef int (*funcBusqueda)(int,int[],int);
const int MIN = 2;
const int MAX = 10;
const int NO_ENCONTRADO = -1;
// Pide al usuario la cantidad de elementos del arreglo
int obtenNumPuntos(int minimo, int maximo)
{
int numPuntos;
do
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
{
for (int i = 0; i < num; i++)
{
cout.width(5);
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Ejemplo 18.37
while (debeBuscar(tipoBusqueda))
{
cout > valorBuscar;
index = buscar(valorBuscar, intArr, num);
if (index != NO_ENCONTRADO)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
// Compara dos enteros
int cmpEnt(const void *item1, const void *item2)
{
return *(int*)item1 - *(int*)item2;
}//Fin de cmpEnt()
// Pide al usuario el número de elementos del arreglo
int obtenNumPuntos(int minimo, int maximo)
{
int numPuntos;
do
{
cout

MIGUEL Á. TOLEDO MARTÍNEZ
}//Fin de busquedaBinaria()
// Verificar la continuidad de búsqueda
bool debeBuscar(const char *tipoBusqueda)
{
char ch;
cout valorBuscar;
indice = buscar(valorBuscar, intArr, num);
if (indice)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
INICIACIÓN DE ARREGLOS
Antes de terminar esta lección, es necesario saber cómo inicializar los arreglos en el
momento en que se definen. Los arreglos, como las variables, se pueden inicializar cuando se
crean. Se pueden suministrar valores de iniciación para cualquier arreglo, mientras esté definido
en el programa. Consideremos algún ejemplo de definición de arreglo para mostrar cómo se
inicializan los arreglos.
int enteros[3] = {10,20,30};
En esta definición, se ha presentado un arreglo entero de tres elementos. Los tres
elementos enteros se han inicializado con los valores 10, 20 y 30, respectivamente. Observe la
sintaxis. La definición del arreglo es seguida por un operador de asignación, al cual le suceden
los valores de inicialización encerrados dentro de llaves. Esto es lo que verá si inspecciona al
arreglo usando un depurador (debugger):
RESULTADOS DEL DEPURADOR
Inspección de enteros
[0] 10
[1] 20
[2] 30
Como puede ver, el primer valor de inicialización, 10, se coloca en el índice 0 del
arreglo; el valor 20 se coloca en el índice 1; y el valor 30 se coloca en la última posición del
índice, que es 2. Ahora, ¿qué se supone que sucedería si proporcionara menos valores de
inicialización que las posiciones en el arreglo? Bueno, suponga que define al arreglo como
sigue:
int enteros[3] = {10,20};
Enseguida se presenta lo que encontrará cuando inspeccione al arreglo usando un
depurador:
RESULTADOS DEL DEPURADOR
Inspección de enteros
[0] 10
[1] 20
[2] 00
Como puede observar, el compilador inicializó la última posición del arreglo con cero.
Cero es el valor de iniciación predeterminado para arreglos de enteros cuando no se
proporcionan suficientes valores para llenar al arreglo.
La siguiente pregunta obvia es: ¿qué sucede si proporciona demasiados valores de
iniciación? Por ejemplo, suponga que define el arreglo como sigue:
int enteros[3] = {10,20,30,40};
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-61

MIGUEL Á. TOLEDO MARTÍNEZ
En este caso, se obtendrá un error de compilación, demasiados inicializadores (too many
initializers) Una forma de solucionar este problema es incrementar el tamaño del arreglo. Otra
forma preferida, es definir al arreglo sin ningún tamaño específico, como sigue:
int enteros[] = {10,20,30,40};
Con esta definición, el compilador establecerá suficiente lugar de almacenamiento para
contener todos los valores de inicialización. Aquí está lo que verá si inspecciona esta definición
de arreglo usando un depurador:
RESULTADOS DEL DEPURADOR
Inspección de enteros
[0] 10
[1] 20
[2] 30
[3] 40
Ahora, vamos a considerar arreglos de caracteres. Suponga que define un arreglo de
caracteres de tamaño cinco, como éste:
char caracteres[5] = {‘H’, ‘E’, ‘L’, ‘L’, ‘O’}
De nuevo se ve que los valores de inicio se encierran en llaves después de un operador de
asignación. Esto mostrará el depurador:
RESULTADOS DEL DEPURADOR
Inspección de caracteres
[0] ‘H’
[1] ‘E’
[2] ‘L’
[3] ‘L’
[4] ‘O’
Aquí se ve que los cinco caracteres de inicio se colocan en el arreglo empezando en el
índice cero y finalizando en la última posición del índice, cuatro. ¿Qué pasa si proporciona
unos cuantos caracteres de iniciación menos que los requeridos para llenar el arreglo?
Bueno, suponga que define el arreglo de esta forma:
char caracteres[5] = {'H','E'};
El contenido del arreglo ahora será corno sigue:
RESULTADOS DEL DEPURADOR
Inspección de caracteres
[0] ‘H’
[1] ‘E’
[2] ‘\0’
[3] ‘\0’
[4] ‘\0’
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-62

MIGUEL Á. TOLEDO MARTÍNEZ
Esta vez, el compilador ha insertado un carácter terminador nulo como un carácter
predeterminado para llenar el arreglo. De otra manera, si proporciona demasiados caracteres,
el compilador generará un mensaje de error demasiados inicializadores. De nuevo, la forma
segura para manejar este problema es dejar que el compilador determine el tamaño del arreglo
para ajustar el número de valores inicializados.
Por último, vamos a considerar cómo se inicializa el arreglo de caracteres con valores de
cadenas. Recuerde, una cadena no es más que un arreglo de caracteres, terminada con un
terminador nulo. Así es como se puede inicializar un arreglo de caracteres con un valor de
cadena:
char caracteres[6] = "HELLO";
Observe que la sintaxis es diferente. La cadena de iniciación deberá encerrarse entre
comillas más que entre llaves. Otra cosa que se ve es que el tamaño del arreglo es uno más
grande que el número de caracteres en la cadena. La razón para esto parece obvia cuando
inspecciona el arreglo usando un depurador. Aquí esta lo que verá:
RESULTADOS DEL DEPURADOR
Inspección de caracteres
[0] ‘H’
[1] ‘E’
[2] ‘L’
[3] ‘L’
[4] ‘O’
[5] ‘\0’
Recuerde que una cadena terminará con un terminador nulo. Al hacer el tamaño del
arreglo uno más grande que el número de caracteres en la cadena, permite espacio para que el
compilador inserte el terminador nulo. Si no se deja espacio para el terminador nulo, éste
quedará truncado (eliminado) del arreglo y no se obtendrá un mensaje de error. De nuevo, la
mejor manera de evitar este problema es permitir que el compilador determine el tamaño del
arreglo, como éste:
char caracteres[] = "HELLO";
Con esta definición, el compilador creará suficientes posiciones en el arreglo para
contener todos los caracteres de cadenas con el terminador nulo insertado como el último
carácter en el arreglo.
INICIACIÓN PREDETERMINADA DE ARREGLOS GLOBALES Y ESTÁTICOS
Se pueden definir e inicializar arreglos en cualquier parte del programa C++. El ámbito
de un arreglo funciona justo como el ámbito de una variable o constante. Un arreglo definido
antes de main() es visible en todo el archivo fuente en el cual se define. Un arreglo definido
dentro de un bloque tiene ámbito de bloque y, por lo tanto, es visible sólo dentro del bloque en
el cual se define.
Si se define un arreglo en forma global o como un arreglo estático y no se proporciona
ningún valor de inicialización, el compilador inicializará el arreglo con el valor predeterminado
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-63

MIGUEL Á. TOLEDO MARTÍNEZ
respectivo (ceros para arreglos de enteros y de punto flotante y terminadores nulos para arreglos
de caracteres) El siguiente es un ejemplo:
int enteros[5];
void main(void)
{
static char caracteres[5];
} // FINAL DE main()
Se ha definido en forma global el arreglo enteros y también como un arreglo estático
local al arreglo caracteres dentro de main() La inspección de estos arreglos con un depurador
revelará lo siguiente:
RESULTADOS DEL DEPURADOR
Inspección de enteros Inspección de caracteres
[0] 0 [0] ‘\0’
[1] 0 [1] ‘\0’
[2] 0 [2] ‘\0’
[3] 0 [3] ‘\0’
[4] 0 [4] ‘\0’
El depurador muestra que el arreglo global de enteros se ha inicializado con ceros,
mientras que el arreglo de caracteres estático se ha inicializado con caracteres de terminador
nulo. Si define un arreglo con ámbito de bloque local que no es estático y no lo inicializa, el
compilador no suministrará ningún valor de inicialización predeterminado. ¡El arreglo
contendrá basura! De esta manera, si elimináramos la palabra clave static de la definición
anterior del arreglo caracteres, el depurador revelará valores arbitrarios de memoria en el
arreglo.
Aquí está un resumen de la explicación anterior:
• Los arreglos de enteros, de punto flotante y de caracteres se inicializan por medio de un
operador de asignación después de la definición del arreglo, seguido por una lista de valores
individuales de inicialización dentro de llaves.
• Menos valores de iniciación darán como resultado valores predeterminados (ceros para
arreglos de enteros y de punto flotante y terminadores nulos para arreglos de caracteres)
insertados en las posiciones adicionales del arreglo.
• Más valores de iniciación provocan un error de compilación.
• Los arreglos de caracteres se pueden inicializar encerrando una cadena con comillas dobles.
• El tamaño de un arreglo de cadena deberá ser uno más grande que el número de caracteres
dentro de la cadena para dejar espacio para el carácter terminador nulo.
• Si no se especifica un tamaño en la definición del arreglo, el compilador creará el suficiente
espacio de almacenaje para los valores de inicialización.
• Los arreglos globales y arreglos estáticos se inicializan siempre con los valores
predeterminados respectivos cuando ningún valor de iniciación se suministra en la definición
del arreglo.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-64

MIGUEL Á. TOLEDO MARTÍNEZ
• Los arreglos locales que no son estáticos no se inicializarán con ningún valor específico, a
menos que se proporcionen en la definición del arreglo.
ARREGLOS QUE REBASAN LOS 64 KBYTES DE MEMORIA
Si un arreglo rebasa los 64 kbytes de longitud, el mismo enviará un mensaje de error
(Array size too large) en tiempo de compilación.
Ejemplo 18.38
Ejemplo 18.39
EXAMEN BREVE 38
El siguiente programa, DEMGDE.CPP, ilustra esta situación.
/* El siguiente programa: DEMGDE.CPP, no se compila correctamente ya que el
arreglo utiliza mas de 64 kbytes de memoria.
*/
void main(void)
{
char cadena[66000L]; // 66,000 bytes
int valores[33000L]; // 33,000 * 2 = 66,000 bytes
float numeros[17000]; // 17,000 * 4 = 68,000 bytes
}//Fin de main()
El siguiente programa ENORME.CPP, ilustra como resolver esta situación.
/* El siguiente programa: ENORME.CPP crea un arreglo de más de 64 kbytes
de datos de punto flotante.
*/
#include //Para cout y cin
#include //Para halloc()
void main (void)
{
int i;
float huge *valores;
if ((valores = (float huge *) halloc (17000, sizeof(float))) == NULL)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
}//Fin de main()
LO QUE NECESITA SABER
for (i = 0; i < 17000; i++)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
Es posible utilizar un arreglo de clase char para almacenar una cadena de caracteres.
Los elementos de un arreglo pueden inicializarse por declaración, por asignación o por
entrada.
Si hay menos inicializadores que elementos en el arreglo, los elementos restantes se
inicializan a cero.
C++ no evita que se haga referencia a elementos que estén fuera de los límites de un
arreglo.
Es posible inicializar un arreglo de caracteres por medio de una literal de cadena.
Todas las cadenas terminan con el carácter nulo (‘\0’)
Los arreglos de caracteres se pueden inicializar con constantes de carácter en una lista
de iniciación.
Es posible acceder a los caracteres de una cadena almacenada en un arreglo por medio
de la notación de índices.
Para pasar un arreglo a una función, hay que pasar su nombre. Para pasar un solo elemento
del arreglo a una función, simplemente hay que pasar el nombre del arreglo seguido por el
índice (entre corchetes cuadrados) de dicho elemento.
Los arreglos se pasan a las funciones simulando una llamada por referencia; las
funciones llamadas pueden modificar los valores de los elementos de los arreglos originales.
El nombre del arreglo es la dirección de su primer elemento. Debido a que se pasa la dirección
de inicio del arreglo, la función llamada sabe exactamente dónde está almacenado dicho
arreglo.
Para recibir un arreglo como argumento, la lista de parámetros de la función debe
especificar que se recibirá un arreglo. No es necesario el tamaño del arreglo entre los
corchetes.
Cuando una función recibe un arreglo como parámetro, la función debe especificar la
clase del arreglo y su nombre, pero no el tamaño del arreglo.
C++ tiene el calificador de clase const, que permite a los programas evitar la modificación,
en una función, de los valores de un arreglo. Cuando un parámetro de arreglo está precedido
por el calificador const, los elementos del arreglo se vuelven constantes en el cuerpo de la
función y cualquier intento por modificarlos provoca un error de sintaxis.
La búsqueda y ordenación son operaciones comunes realizadas sobre arreglos.
Los arreglos pueden ordenarse mediante la técnica de ordenamiento de burbuja. Se
realizan varias pasadas al arreglo. Con cada pasada se comparan los pares consecutivos de los
elementos. Si un par está ordenado (o sus valores son idénticos), se deja tal cual. Si está fuera
de orden, se intercambian. El ordenamiento de la burbuja es aceptable en los arreglos
pequeños, pero en los mayores es ineficiente en comparación con otros algoritmos de
ordenamiento más complejos.
La búsqueda secuencial es una búsqueda iterativa que busca un valor dado en un arreglo,
comparando en forma secuencial el valor con los elementos del arreglo, empezando con el
primer elemento del arreglo, hasta que se encuentra el valor en el arreglo o hasta que se
alcanza el final del arreglo.
La búsqueda lineal compara todos los elementos de un arreglo con la clave de búsqueda. Si el
arreglo no está en ningún orden en particular, existe la misma probabilidad de que el valor se
encuentre en el primer elemento como que esté en el último. Por lo tanto, en promedio, el
programa tendrá que comparar la clave de búsqueda con la mitad de los elementos del arreglo.
El método de búsqueda lineal funciona bien con los arreglos pequeños y es aceptable si se
trata de arreglos desordenados.
Una búsqueda binaria puede ser iterativa o recursiva. Una búsqueda binaria divide el arreglo
en mitades, dirigiéndose a sí misma hacia la mitad en donde es muy probable que se encuentre
el valor.
La búsqueda binaria requiere que el arreglo esté ordenado, mientras que la búsqueda
secuencial no tiene este requerimiento.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-67

MIGUEL Á. TOLEDO MARTÍNEZ
Por otra parte, la búsqueda binaria es mucho más rápida que la secuencial, especialmente en
grandes arreglos ordenados.
La búsqueda binaria elimina de su consideración la mitad de los elementos del arreglo tras
cada comparación; esto lo logra localizando el elemento central del arreglo y comparándolo
con la clave de búsqueda. Si son iguales, entonces se encuentra la clave de búsqueda y se
devuelve el índice de dicho elemento. De otra manera, se reduce el problema a la búsqueda en
una mitad del arreglo.
En el peor caso, la búsqueda en un arreglo de 1024 elementos sólo necesitaría 10
comparaciones y se efectúa mediante búsqueda binaria.
Muchas aplicaciones en el mundo real requieren que la información esté ordenada. Hay
algunos algoritmos de clasificación comunes, incluyendo clasificación por inserción,
clasificación por burbuja, clasificación por selección y clasificación rápida.
Todos estos algoritmos operan sobre arreglos. El algoritmo de clasificación por inserción
es un proceso iterativo que inserta un elemento dado en el arreglo en su lugar correcto relativo
a los elementos que lo preceden en el arreglo. Usted se familiarizará con la clasificación de
burbuja y la clasificación de selección en los problemas de esta lección.
PREGUNTAS Y PROBLEMAS
PREGUNTAS
1. Llene los siguientes espacios en blanco:
a. Las listas y tablas de valores se guardan en ________________________.
b. Los elementos de un arreglo se relacionan por el hecho de que tienen el mismo __________ y
_____________.
c. El número con el que se hace referencia a un elemento en particular de un arreglo se llama
_____________.
d. Debe usarse una _______________ para declarar el tamaño de un arreglo, pues hace más escalable el
programa.
e. El proceso de colocar en orden los elementos en un arreglo se llama _______________ del arreglo.
f. El proceso con el que se determina si un arreglo contiene cierto valor clave se llama ____________.
g. C++ almacena las listas de valores en _________________.
h. Al referirse a un elemento de un arreglo, el número de posición contenido entre paréntesis se llama
_____________.
i. Los nombres de los cuatro elementos del arreglo p son __________, _____________, _________ y
___________.
j. La denominación de un arreglo, indicación de su clase y especificación de la cantidad de elementos que
hay en él se llama _____________ del arreglo.
k. El proceso de colocación de los elementos de un arreglo en orden ascendente o descendente se llama
_____________.
2. Indique si las siguientes oraciones son falsas o verdaderas. Si la respuesta es falso explique por qué.
a. Un arreglo puede contener diferentes clases de valores.
b. Los índices de los arreglos normalmente deben de ser de clase float.
c. Si hay menos inicializadores en una lista de iniciación que el número de elementos que hay en el
arreglo, los elementos restantes se inicializan automáticamente al último valor de dicha lista.
d. Es un error que una lista de iniciación contenga más inicializadores que la cantidad de elementos que
hay en el arreglo.
e. Un elemento de un arreglo que se pasa a una función y se modifique ahí contendrá el valor modificado
cuando termine la ejecución de la función llamada.
f. Para hacer referencia a una localidad particular o elemento de un arreglo, se especifica el nombre del
arreglo y el valor del elemento.
g. Una declaración de arreglo reserva espacio para el arreglo.
h. Para indicar que se deben reservar 100 localidades para el arreglo de enteros p, el programador
escribirá la declaración
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-68

MIGUEL Á. TOLEDO MARTÍNEZ
p[100];
i. Un programa C++ que inicialice a 0 los elementos de un arreglo de 15 elementos debe contener cuando
menos una instrucción for.
3. Conteste las siguientes preguntas relacionadas con un arreglo llamado fracciones.
a. Defina una variable constante tamanoArreglo que se inicialice a 10.
b. Declare un arreglo con elementos tamanoArreglo de la clase float e inicialice dichos elementos a 0.
c. Nombre el cuarto elemento a partir del inicio del arreglo.
d. Haga referencia al elemento 4.
e. Asígnele el valor 1.667 al elemento 9.
f. Asígnele el valor 3.333 al séptimo elemento del arreglo.
g. Imprima los elementos 6 y 9 del arreglo con una precisión de dos dígitos a la derecha del punto decimal y
muestre la salida que se desplegará en la pantalla.
h. Imprima todos los elementos del arreglo mediante una estructura de repetición for. Defina la variable
entera x como la variable de control del ciclo. Muestre la salida.
4. Encuentre los errores en los siguientes segmentos de programa y corríjalos.
a. #include ;
b. tamanoArreglo = 10; //tamanoArreglo se declaró como const
c. Suponga que int b[10] = {0};
5.
for(int i = 0; i

MIGUEL Á. TOLEDO MARTÍNEZ
16. Escriba un enunciado para definir un arreglo de punto flotante que se inicializará con ceros y es local para
main()
17. ¿Dónde está el error en la siguiente definición del arreglo?
18. Dada la siguiente definición de arreglo,
int números[4] = {0,1,2,3,4};
int valores[10];
a. Escriba un enunciado para colocar el producto del primero y segundo elementos de arreglo en la
posición del último elemento.
Use la siguiente definición de arreglo para contestar las preguntas 19 - 23:
const int MAX = 4;
char cadena[MAX] =“C++”;
19. Escriba el prototipo para una función de nombre longitudCadena() que recibirá el arreglo completo y
regresa la longitud de la cadena.
20. Escriba un prototipo para una función de nombre elementoCadena() que recibirá un elemento sencillo de la
cadena, de manera que cualquier operación sobre ese elemento dentro de la función no afectará el valor del
elemento dentro del arreglo.
21. Escriba un enunciado para llamar la función de la pregunta 19 y pase el primer elemento del arreglo a la
función.
22. Escriba un prototipo para una función de nombre cambiaElemento() que recibirá un solo elemento de la
cadena, de manera que cualquier modificación en este elemento dentro de la función cambie el valor del
elemento en el arreglo.
23. Escriba un enunciado para llamar a la función de la pregunta 22 y pase el último elemento del arreglo a la
función.
24. En general, ¿qué posición del elemento se regresará por medio de las funciones de búsqueda secuencial y
binaria desarrolladas en esta lección, si un elemento se presenta varias veces en el arreglo?
25. ¿Por qué, en promedio, es más rápida la búsqueda binaria que la secuencial?
26. ¿Cuándo es más rápida la búsqueda secuencial que la binaria?
27. Revise el algoritmo clasifPorInser() para ordenar el arreglo de modo descendente.
PROBLEMAS
1. Escriba un programa para llenar un arreglo con todos los enteros impares desde 1 hasta 99. Escriba una
función para llenar el arreglo y otra para mostrar éste, desplegando en la pantalla los enteros impares
separados por comas.
2. Escriba una función para leer el nombre del usuario desde la entrada del teclado y colóquelo en un arreglo
de caracteres. Escriba otra función para mostrar el nombre del usuario almacenado en el arreglo. Verifique
sus funciones por medio de un programa de aplicación.
3. Escriba un programa para leer una lista de 25 elementos de caracteres desde una entrada de teclado y
muéstrelos en orden inverso. Use una función para llenar la lista con los elementos escritos y otra para
mostrarla.
4. Escriba un programa que use seis arreglos de caracteres para almacenar el nombre del usuario, domicilio,
ciudad, estado, código postal y número telefónico. Proporcione una función para llenar los arreglos y
otra para mostrar el contenido del arreglo usando un formato de direccionamiento apropiado.
5. (La coladera de Eratóstenes) Un entero primo es cualquier entero que es divisible sólo entre él mismo y
entre 1. La coladera de Eratóstenes es un método para encontrar números primos. Opera como sigue:
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-70

MIGUEL Á. TOLEDO MARTÍNEZ
a) Cree un arreglo con todos los elementos inicializados a 1 (verdadero) Los elementos del arreglo que
tengan índices primos permanecerán en 1. Los demás elementos del arreglo en algún momento se
establecerán a cero.
b) Comenzando por índice 2 (el índice 1 debe ser primo), cada vez que se encuentre un elemento del
arreglo que sea 1, haga un ciclo por el resto del arreglo y establezca a cero todos los elementos cuyo
índice sea un múltiplo de dicho índice. Para el índice 2, todos los elementos por encima de 2 que sean
múltiplos de 2 se establecerán a cero (los índices 4, 6, 8, 10, etc.); en el caso del índice 3, todos los
elementos por encima de 3 que sean múltiplos de 3 se establecerán a cero (índices 6, 9, 12, 15, etc.); y
así sucesivamente.
Terminado este proceso, los elementos del arreglo que aún estén establecidos a 1 indicarán que el índice
es un número primo, así que podrán imprimirse. Escriba un programa con un arreglo de 1000
elementos que determine e imprima los números primos entre 1 y 999. Ignore el elemento 0 del
arreglo.
6. Por medio de un arreglo de un solo índice resuelva el siguiente problema. Una compañía paga a sus
vendedores con base en una comisión. Los vendedores reciben $200 a la semana más 9% de sus ventas
netas durante la semana. Por ejemplo, un vendedor cuyas ventas brutas son de $5000, a la semana recibe
$200 más 9% de $5000, es decir un total de $650. Escriba un programa (con un arreglo de contadores) que
determine la cantidad de vendedores que ganaron salarios dentro de los siguientes rangos (suponga que el
salario de cada vendedor se cierra a una cifra entera):
a) $200 - $299
b) $300 - $399
c) $400 - $499
d) $500 - $599
e) $600 - $699
f) $700 - $799
g) $800 - $899
h) $900 - $999
i) $1000 o más
7. El ordenamiento por el método de la burbuja elaborado en el ejemplo 18.26. es ineficiente en el caso de
arreglos grandes. Haga las siguientes modificaciones sencillas que mejorarán el desempeño del
ordenamiento de burbuja.
a) Después de la primera pasada, se garantiza que la cifra mayor es el elemento de mayor índice del
arreglo, tras la segunda pasada, los dos números mayores están en su lugar, etc. En lugar de hacer
nueve comparaciones con cada pasada, modifique el ordenamiento de burbuja para que efectúe ocho
comparaciones en la segunda pasada, siete en la tercera, etc.
b) Los datos en el arreglo tal vez ya estén en el orden adecuado, o casi, así que ¿por qué hacer nueve
pasadas si tal vez baste con menos? Modifique el ordenamiento para comprobar al final de cada pasada
si se han hecho intercambios. Si no ha sucedido ninguno, entonces los datos ya estarán en orden y
deberá terminar el programa. Si han sucedido intercambios, entonces se necesita cuando menos otra
pasada.
8. Escriba instrucciones que lleven a cabo las siguientes operaciones sobre arreglos de un solo índice. Debe ser
una sola instrucción por cada una.
a) Inicialice a cero los 10 elementos del arreglo de enteros contador.
b) Sume 1 a cada uno de los 15 elementos del arreglo de enteros bonos.
c) Lea del teclado 12 valores para el arreglo float temperaturaMensual.
d) Imprima los 5 valores del arreglo de enteros mejoresCalificaciones en formato de columnas
9. Encuentre el error o los errores en las siguientes instrucciones:
a) Suponga que: char cadena[5];
cin >> cadena; //El usuario teclea bello
b) Suponga que: int a[3];
cout

MIGUEL Á. TOLEDO MARTÍNEZ
c) float f[3] = {1.1, 10.01, 100.001, 1000.0001};
10. Modifique el ejemplo 18.32 para que la función moda() pueda manejar empates en el valor de la moda.
También modifique la función mediana() de modo que se promedien los dos elementos centrales cuando se
trate de un arreglo con un número par de elementos.
11. Con un arreglo de un solo índice resuelva el siguiente problema. Lea 20 números entre 10 y 100, inclusive. A
medida que se lea cada número, imprímalo sólo si no es un duplicado de algún número ya leído. Tome en
cuenta el peor caso, cuando todos los números son diferentes. Resuelva este problema empleado el arreglo
más pequeño posible.
12. Escriba un programa que simule el lanzamiento de dos dados. El programa deberá valerse de rand() para
lanzar el primer dado y nuevamente rand() para lanzar el segundo. Luego debe calcular la suma de ambos
valores. Nota: debido a que cada dado puede tener un valor entero de 1 a 6, entonces la suma de ambos
valores variará de 2 a 12, siendo 7 la suma más frecuente y 2 y 12 las menos frecuentes. La figura 18.5
muestra las 36 combinaciones de dados posibles. Su programa deberá lanzar ambos dados 36,000 veces.
Mediante un arreglo de un solo índice, registre la cantidad de veces que aparece cada suma. Imprima el
resultado en formato de tabla. Además determine si los totales son razonables, es decir, hay seis maneras de
lanzar 7, por lo que aproximadamente una sexta parte de los lanzamientos debe ser 7.
1 2 3 4 5 6
1 2 3 4 5 6 7
2 3 4 5 6 7 8
3 4 5 6 7 8 9
4 5 6 7 8 9 10
5 6 7 8 9 10 11
6 7 8 9 10 11 12
Figura 18.5. Las 36 posibles combinaciones de lanzamiento de dos dados.
13. ¿Qué hace el siguiente problema?
// Nombre del programa: PROBLEMA11.CPP
#include
int queEsEsto(int[], int);
void main(void)
{
const int TAMANO_ARREGLO = 10;
int a[TAMANO_ARREGLO] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
}
int resultado = queEsEsto(a, TAMANO_ARREGLO);
cout

MIGUEL Á. TOLEDO MARTÍNEZ
d) ¿cuál es la duración promedio de un juego de dados?
e) ¿Mejoran las posibilidades de ganar a medida que aumenta la duración del juego?
15. (Sistema de reservaciones de una aerolínea) Una línea aérea pequeña acaba de comprar una computadora para
su nuevo sistema automatizado de reservaciones. Se le ha pedido a usted que programa este sistema. Deberá
escribir un programa que asigne asientos en cada vuelo del único avión de la compañía (capacidad: 10
asientos)
Su programa deberá presentar el siguiente menú de alternativas:
Por favor teclee 1 para fumar.
Por favor teclee 2 para no fumar.
Si se teclea 1, el programa deberá asignar un asiento en la sección de fumadores (asientos 1 a 5) Si se
teclea 2, se asignará un asiento en la sección de no fumar (asientos 6 a 10). El programa deberá imprimir un
pase de abordar que indique el número de asiento del pasajero y si se trata de la sección de fumar o de no
fumar.
Mediante un arreglo de un solo índice, represente la gráfica de asientos del avión. Inicialice a cero todos
los elementos del arreglo, indicando que todos los asientos están vacíos. A medida que se asigne un asiento,
establezca a 1 el elemento correspondiente, indicando que ya no está disponible.
El programa, claro está, no deberá volver a asignar un asiento ya asignado. Cuando la sección de
fumadores esté llena, el programa deberá preguntar si es aceptable asignar un asiendo en la sección de no
fumar (y viceversa) Si la respuesta es sí, entonces haga la asignación. Si no, imprima el mensaje el próximo
vuelo parte en tres horas.
16. ¿Qué hace el siguiente programa?
// PROGRAMA14.CPP
#include
void ciertaFunción(int[], int);
void main(void)
{
const int TAMANO_ARREGLO = 10;
int a[TAMANO_ARREGLO] = {32, 27, 64, 18, 95, 14, 90, 70, 60, 37};
}
cout

MIGUEL Á. TOLEDO MARTÍNEZ
srand(1);
for(int l = 0; 1 < 10; ++1)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
medio de la función clasifPorBur() para intercambiar dos elementos del arreglo como se muestra
en el algoritmo. Escriba sus funciones para clasificar un arreglo de caracteres. Incorpórelas dentro
de un programa para que verifique el procedimiento de clasificación. ¿Por qué la clasificación
por burbuja es menos eficiente que la clasificación por inserción?
21. Otro algoritmo de clasificación iterativa común es clasificación por selección. El algoritmo es como éste:
clasifPorSelec()
Inicio
para indice1 = (primer índice del arreglo) hasta (ultimo índice del arreglo) hacer
posición = indice1.
masPequeno = A[Posicion].
para indice2 = (indice1 + 1) hasta (ultimo índice del arreglo) hacer
si A[indice2] < masPequeno
posicion = indice2.
masPequeno = A[posicion].
A[posicion] = A[indice1].
A[indice1] = masPequeno.
Fin.
Como en la clasificación por burbuja, la clasificación por selección realiza diversos pasos a través
del arreglo. En el primero de ellos examina al arreglo completo y coloca los elementos más
pequeños en la primera posición del arreglo. En el segundo paso se examina el arreglo empezando
en el segundo elemento. Se encuentra el elemento más pequeño en el segmento del arreglo y se
coloca en la segunda posición del arreglo. El tercer paso examina el arreglo empezando en el tercer
elemento, encuentra el elemento más pequeño en el segmento del arreglo y lo coloca en la tercera
posición del elemento. El proceso continúa hasta que no quedan más segmentos del arreglo.
Su trabajo es codificar el algoritmo anterior como una función C++ de nombre clasifPorSelec()
Escriba su función para clasificar un arreglo de caracteres. Después úsela en un programa que
verifique el procedimiento de clasificación.
¿Por qué la clasificación por selección es menos eficiente que la clasificación por inserción?
22. Escriba un programa que tome un arreglo entero sin ordenar y encuentre la localización del valor
máximo en el arreglo. (Sugerencia: copie el arreglo dentro de otro y clasifique este segundo arreglo
para determinar su valor máximo. Después busque el arreglo original para este valor)
Problemas de recursividad
23. (Ordenamiento por selección) El ordenamiento por selección busca en un arreglo el elemento más pequeño, el
cual se intercambia con el primero del arreglo. El proceso se repite con el subarreglo que comienza en el
segundo elemento del arreglo. Cada pasada por el arreglo da como resultado la colocación de un elemento en su
lugar correcto. El desempeño de este ordenamiento es comparable con el ordenamiento de burbuja: para un
arreglo de n elementos, se necesita hacer n-1 pasadas y por cada subarreglo, hay que hacer n-1 comparaciones
para encontrar el valor más pequeño. Cuando el subarreglo que se está procesando sólo contiene un elemento, el
arreglo está ordenado. Escriba la función recursiva clasifOrdenamiento()
24. (Palíndromos) Un palíndromo es una cadena que se pronuncia igual hacia delante que hacia atrás. Algunos
ejemplos son: radar, anilina y dábale arroz a la zorra el abad. Escriba una función recursiva
pruebaPalindrome() que devuelva verdadero si la cadena almacenada en el arreglo es un palíndromo y falso si
no. La función deberá ignorar los espacios y la puntuación en la cadena.
25. (Búsqueda lineal) Modifique el ejemplo 18.33 para que emplee la función recursiva busquedaBinaria() para
llevar a cabo una búsqueda lineal en el arreglo. La función deberá recibir como argumentos un arreglo de
enteros y su tamaño. Si se encuentra la clave de búsqueda, devuelva el índice del arreglo; de otro modo,
devuelva –1.
26. (Búsqueda binaria) Modifique el programa del ejemplo 18.34 para que utilice una función recursiva
busquedaBinaria() que lleve a cabo una búsqueda binaria en el arreglo. La función deberá recibir como
argumentos un arreglo de enteros y el índice inicial y el final. Si se encuentra la clave de búsqueda, devuelva el
índice del arreglo; de otro modo, devuelva –1.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-75

MIGUEL Á. TOLEDO MARTÍNEZ
27. (Impresión de un arreglo) Escriba una función recursiva imprimirArreglo() que tome como argumentos un
arreglo y su tamaño y no devuelva nada. La función deberá terminar el proceso y regresar cuando reciba un
arreglo de tamaño cero.
28. (Impresión inversa de una cadena) Escriba una función recursiva cadenaInvertida() que tome un arreglo de
caracteres que contenga como argumento una cadena, la imprima al revés y no devuelva nada. La función
deberá terminar el proceso y regresar cuando se encuentre el carácter nulo de terminación.
29. (Encuentre el valor mínimo dentro de un arreglo) Escriba una función recursiva minimoRecursivo() que tome
como argumentos un arreglo de enteros y su tamaño y devuelva su elemento más pequeño. La función deberá
terminar el proceso y regresar cuando reciba un arreglo de 1 elemento
EXAMEN BREVE 34
1. Los dos componentes principales de un arreglo son: ______________ y ___________.
2. Verdadero o falso: Los elementos dentro de un arreglo determinado pueden ser de cualquier
combinación de clase de datos.
EXAMEN BREVE 35
1. Defina un arreglo de nombre registrosDeExamen que almacene hasta 15 registros de exámenes.
2. ¿Cuál es la dimensión del arreglo en la pregunta 1?
3. ¿Cuál es el índice del primer elemento del arreglo en la pregunta 1?
4. ¿Cuál es el índice del último elemento del arreglo en la pregunta 1?
5. Defina un arreglo de nombre esteSemestre que almacene elementos de una clase enumerada de
nombre cursos, que incluya los cursos que usted está tomando este semestre.
6. Suponga que el índice del último elemento en un arreglo es [25] ¿Cuántos elementos almacenará el
arreglo?
EXAMEN BREVE 36
1. Escriba un ciclo for que llene el siguiente arreglo desde la entrada del usuario: char caracteres[15];
2. Escriba un ciclo for que muestre el contenido del arreglo de la pregunta 1.
EXAMEN BREVE 37
1. Verdadero o falso: el nombre del arreglo es la dirección del índice[1] del arreglo.
2. Escriba un prototipo para una función de nombre muestra() que modifique al siguiente arreglo:
char caracteres[15];
Suponga que la función no regresa ningún valor excepto el arreglo modificado.
3. Escriba un prototipo para una función de nombre prueba() que modifique un solo elemento del
arreglo que se definió en la pregunta 2.
4. Escriba un enunciado que llamará a la función prototipo elaborada en la pregunta 3 para modificar
el elemento almacenado en el índice[5] del arreglo definido en la pregunta 2.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-76

MIGUEL Á. TOLEDO MARTÍNEZ
EXAMEN BREVE 38
1. Defina un arreglo e inicialícelo con los valores enteros de -3 hasta +3.
2. ¿Cuál es la dimensión del arreglo que definió en la pregunta 1?
3. Muestre el contenido del siguiente arreglo:
char lenguaje[51 = {‘C’, ‘+’, ‘+’};
4. Muestre el contenido del siguiente arreglo:
char lenguaje[] = " C++";
5. Suponga que define globalmente un arreglo de caracteres sin valores de iniciación. ¿Qué almacena
el compilador en el arreglo?
RESPUESTA EXAMEN BREVE 34
1. Los dos componentes principales de un arreglo son: indice y elemento.
2. Falso: Todos los elementos dentro de un arreglo deben de ser de la misma clase de datos.
1. float registrosDeExamen[15];
RESPUESTA EXAMEN BREVE 35
2. La dimensión del arreglo de la pregunta 1 es 1 ××××15.
3. El índice del primer elemento del arreglo de la pregunta 1 es [0]
4. El índice del último elemento en el arreglo de la pregunta 1 es [14]
5. enum cursos {Computacion, Matematicas, Física, Ingles, Oratoria};
cursos esteSemestre[5];
6. El arreglo almacenará 26 elementos, dado que el primer índice de elemento es [0]
RESPUESTA EXAMEN BREVE 36
1. El ciclo for que se necesita para llenar el arreglo char caracteres[15]; es:
for(int indice = 0; indice < 15; ++indice)
cin >> caracteres[indice];
2. El ciclo for que mostrará el contenido del arreglo anterior es:
for(int indice = 0; indice < 15; ++indice)
cout

MIGUEL Á. TOLEDO MARTÍNEZ
3. Un prototipo para una función llamada prueba() que modificará sólo un elemento en el arreglo de la
pregunta 2 es:
void prueba(char &elementoDelArreglo);
4. Un enunciado que llamará a la función anterior para modificar el elemento almacenado en el
índice[5] del arreglo en la pregunta 2 es:
prueba(caracteres[5]);
RESPUESTA EXAMEN BREVE 38
1. La definición de un arreglo inicializado con los valores enteros de –3 a +3 es:
int numeros[7] = [-3, -2, -1, 0, 1, 2, 3};
o
int numeros[] = [-3, -2, -1, 0, 1, 2, 3};
2. La dimensión del arreglo antes mencionado es 1 x 7.
3. El contenido del arreglo char lenguaje[51 = {‘C’, ‘+’, ‘+’}; es:
[‘C] [‘+’] [‘+’] [‘\0’] [‘\0’]
4. El contenido del arreglo char lenguaje[] = "C++"; es;
[‘C] [‘+’] [‘+’] [‘\0’]
5. Un carácter terminador nulo (‘\0’) se coloca en cada posición de un arreglo de caracteres definido
globalmente sin ningún valor de inicialización.
ARREGLOS, APUNTADORES Y ESTRUCTURAS – LECCIÓN 18 18-78