3 Contenido de un arreglo

Tabla de contenido
Mapa de navegación .......................................................................................... 3
1 Home ............................................................................................................... 4
2 Definiciones ..................................................................................................... 5
2.1 Qué es un arreglo? ................................................................................... 5
2.2 De qué se compone un arreglo? ............................................................... 6
2.3 Diferencias ................................................................................................ 6
2.4 Ejercicio .................................................................................................... 7
3 Contenido de un arreglo .................................................................................. 8
3.1 ¿Qué puede ir dentro de un arreglo? ........................................................ 8
3.2 ¿Cómo se lee un valor de un arreglo? .................................................... 12
3.3 ¿Cómo escribo un valor en un arreglo? .................................................. 13
3.4 Ejercicio .................................................................................................. 13
4 Declaración de un arreglo ............................................................................. 14
4.1 Sintaxis ................................................................................................... 14
4.2 Inicialización de un arreglo ..................................................................... 16
4.2.1 Por ciclos.......................................................................................... 17
4.2.2 Lista de inicialización........................................................................ 20
4.2.3 Por cálculos ...................................................................................... 21
4.2.4 Qué pasa si…… ............................................................................... 22
4.3 Ejercicio .................................................................................................. 23
5 Matrices ......................................................................................................... 24
5.1 Cuestiones básicas ................................................................................. 24
5.2 Inicialización ........................................................................................... 26
5.2.1 Inicialización por ciclos ..................................................................... 27
5.2.2 Listas de inicialización ...................................................................... 27
5.2.3 Por cálculos ...................................................................................... 29
5.3 ¿Cómo leo en una matriz? ...................................................................... 29
5.4 ¿Cómo escribo en una matriz? ............................................................... 30
5.5 Ejercicio .................................................................................................. 31
6 Ordenamientos .............................................................................................. 32
6.1 Burbuja ................................................................................................... 32
6.2 Ejercicio .................................................................................................. 35
7 Búsquedas .................................................................................................... 36
7.1 Lineal ...................................................................................................... 36
7.2 Binaria..................................................................................................... 37
7.3 Ejercicio .................................................................................................. 38
8 Evaluación ..................................................................................................... 39
Mapa de navegación
1. Home
2. Definiciones
1. Qué es un arreglo (Definición)
2. De qué se compone un arreglo (nombre, posición),
3. Diferencias
1. índice, posición y valor
2. longitud y cantidad de elementos
4. Ejercicio
3. Contenido de los arreglos
1. ¿Qué puede ir dentro de un arreglo?
2. ¿Cómo leo y cómo escribo en un vector?
3. Ejercicio
4. Declaración de un arreglo
1. Sintaxis
2. Inicialización de un arreglo
1. Por ciclos
2. Lista de inicialización
3. Por cálculos
3. Ejercicio
5. Matrices
1. Cuestiones generales (doble subíndice q se usa para identificar
un elemento en particular)
2. Inicialización
3. ¿Cómo leo y cómo escribo en una matriz?
4. Ejercicio
6. Ordenamientos
1. Burbuja
2. Ejercicio
7. Búsquedas
1. Lineal
2. Binaria
3. Ejercicio
8. Evaluación (o ejercicios de repaso)
1 Home
Hola. Bienvenido a VMCreative. A lo largo de la aplicación verás cómo
aplicamos los conceptos de arreglos en un caso de cercana relación: la caja de
huevos. Asimismo, podrás hacer ejercicios que refuercen los conceptos
presentados y te ayuden a comprender mejor el funcionamiento de los
conceptos.
Antes de comenzar, recuerda que cuando hablamos de arreglos nos referimos
a vectores y matrices y que cada tipo de dato se interpreta con un color
diferente:
Entero  azul
String  amarillo
Booleano  rojo
Carácter  verde
Flotante  morado
Ahora sí, comencemos!
2 Definiciones
Pulsa clic en alguna de las opciones (en realidad, es una forma de invitar al
usuario a q elija entre las opciones de qué es un arreglo, de qué se compone y
las diferencias básicas)
2.1 Qué es un arreglo?
Básicamente un arreglo es una colección de elementos de un solo tipo de
datos………. O sea que en la caja sólo voy a obtener colecciones de huevos de
un solo color.
(Botón next)
Todo arreglo se divide en dos categorías:
- Vectores: Arreglos de una sola fila. (la idea es q al ladito solo aparezca
una fila de la caja de huevos)
- Matrices: Arreglos de 2 o más filas. (aquí aparecería la caja de huevos
completa)
(Botón next)
La característica principal de todo arreglo es el hecho de ser estático: mientras
estés ejecutando un arreglo no se le puede cambiar el tamaño. Lo puedes ver
en el ejemplo: escribe un valor para las filas y otro para las columnas y
después intenta cambiarlo (aquí la idea es mostrar en dos campos de texto
ubicados a un lado de la pantalla la longitud en filas y columnas que va a tener
la matriz y que al presionar el botón “Listo” se muestren los huevos. La idea es
que el estudiante al volver a digitar algún valor en los campos de texto, le
aparezca el mensaje de que no puede volver a cambiar ni la fila ni la columna
de los arreglos)
Vuelvo a digitar algún valor en las
filas o las columnas? Ahí la
animación me debe soltar un
mensaje q diga “No se puede
cambiar los parámetros de un
arreglo en tiempo de ejecución“
(Botón next)
2.2 De qué se compone un arreglo?
Todo arreglo se compone de:
- Nombre del arreglo: Nombre con el que se identifica el arreglo
- Posición: Elemento del arreglo escrito en llaves [ ] y que adentro tiene un
índice que es número entero. Si el arreglo es de dos dimensiones,
habrán dos llaves y dentro de cada una se manejará un índice.
MPORTANTE: Todo arreglo comienza desde la posición que lleva el índice 0.
Por lo tanto, suponiendo que el arreglo se llama c, la primera posición será c[0],
la segunda posición será c[1] y así sucesivamente…
(La idea aquí es q se muestre una animación sincronizada: cuando se enuncie
“nombre del arreglo” se muestre una letra a, y cuando se mencione posición se
muestre las llaves [], un símbolo igual y un huevo. Para la parte en la que se
dice q si el arreglo es de 2 dimensiones, la idea es mostrar la cadena “a [ ][ ] =”
y delante de la cadena dos huevos)
(Botón next)
2.3 Diferencias
Un índice es el número que se encuentra dentro de las llaves, es el
identificador del arreglo.
La posición es el lugar del arreglo en donde se ubica un valor. Por ejemplo, si
se escribe a[1], me referiría a la segunda posición del arreglo ya que la primera
posición es a[0].
El valor es la cantidad que guarda una posición del arreglo.
Asimismo, puedo llamar a los índices por medio de operaciones matemáticas…
Por ejemplo, si un arreglo a se denota como a[3+2], es lo mismo que estuviese
haciendo a[5] o lo que es equivalente, llamar a la sexta posición del arreglo a.
2.4 Ejercicio
Si haces clic en la primera posición del arreglo b (cuadro referenciado como
b[0]), te vas a dar cuenta de que el valor que contiene es el número -4, si haces
clic en la segunda posición del arreglo (b[1]) el valor que muestra será 5, en el
tercero (b[2]) mostrará el valor 22, en el cuarto (b[3]) mostrará -15 y en el quinto
(b[4]) mostrará el valor 10.
3 Contenido de un arreglo
3.1 ¿Qué puede ir dentro de un arreglo?
Se habla de que pueden contener enteros, booleanos, caracteres (arreglos con
caracteres son los conocidos como cadenas de caracteres y ahí se debe
especificar el símbolo de finalización)
Recuerda que dentro de un arreglo sólo almacena valores de un solo tipo de
dato. Haz clic sobre alguna de las opciones para mayor información:
Aquí se mostraría la imagen de un establo como fondo y el mensajito q puede
aparecer volando. La idea de los botones es q puedan aparecer todos también
en una forma de animación (no sé si estos botones deban quedar abajo para
que dé más espacio para ver el contenido, la idea es q uno haga clic en alguno
de los botones y muestre un texto pequeño y una animación)
Botón “Enteros”:
Se encarga de mostrar y almacenar en el arreglo cantidades positivas,
negativas y el cero.
Aquí tanto el texto como los huevos aparecerían en pantalla luego de q hicieran
un movimiento. Cada huevo mostraría un valor como se hizo en la animación
de antes. Cada huevo mostraría un valor como 6, 34, 109, -2, 0. Sería chévere
que para mostrar los huevos, se ponga una animación de una gallina que
recorra horizontalmente la pantalla botando o desempollando los huevos
emitiendo su respectivo sonido, por ejemplo, un plop
Botón “Flotantes”:
Almacena y muestra en un arreglo números que poseen parte entera (los que
están delante de la coma) y parte decimal (los que están detrás de la coma)
Aquí tanto el texto como los huevos aparecerían en pantalla luego de q hicieran
un movimiento. Cada huevo mostraría un valor como se hizo en la animación
de antes. Cada huevo mostraría un valor como 3.14; 2.34345; -0.1; -5.09; 3.69.
Sería chévere que para mostrar los huevos, se ponga una animación de una
gallina que recorra horizontalmente la pantalla botando o desempollando los
huevos emitiendo su respectivo sonido, por ejemplo, un plop
Botón “Booleanos”:
Almacena y muestra en sus posiciones sólo valores “Verdadero” o “Falso” en
cada posición del arreglo.
Aquí tanto el texto como los huevos aparecerían en pantalla luego de q hicieran
un movimiento. Cada huevo mostraría un valor como se hizo en la animación
de antes. Cada huevo mostraría un valor como verdadero, falso, falso,
verdadero, verdadero. Sería chévere que para mostrar los huevos, se ponga
una animación de una gallina que recorra horizontalmente la pantalla botando o
desempollando los huevos emitiendo su respectivo sonido, por ejemplo, un
plop
Botón “String”:
Un String es un tipo de dato compuesto, es decir, que está formado de valores
de cierto tipo de dato. En este caso, un string resulta de combinar un grupo de
caracteres.
Básicamente se muestra una animación con un huevo amarillo que adentro
tiene la palabra “casa” y al lado aparecen 4 huevos verdes uno con cada letra
de la palabra “casa”. Para q aparezcan los huevos, lo mismo, poner a una
gallina a q bote los huevos y un sonido q reproduzca esta acción.
(botón next)
Es importante recordar que, sumado a los caracteres, un string contiene un
símbolo de terminación de la cadena conocido como ‘\0’. Este valor se ubica
después de poner todos los caracteres y además de ser invisible a la hora de
imprimir la cadena en la pantalla.
Aquí, se muestran la palabra casa, los 4 huevos de la animación anterior y el
texto de arriba. La idea es mostrar una animación que borre la palabra y
presente los huevos más en el centro.
Luego, aparece de la nada un huevo de color verde claro con el valor \0.
Después, abajo aparecerá una cadena que dice resultado = ´casa´
3.2 ¿Cómo se lee un valor de un arreglo?
Para que el depurador pueda leer un elemento de un arreglo, simplemente
basta con que él pueda acceder al arreglo en el subíndice que él desee.
(botón next)
Otra forma sería ayudándonos por medio de una variable del mismo tipo de
dato que el arreglo.
Para que pueda imprimirse en pantalla y el usuario lo pueda ver, entonces
utilizaría el comando “cout<<” y llamaría o bien a la variable que se le asignó el
valor o directamente al elemento del arreglo que se desea mostrar.
3.3 ¿Cómo escribo un valor en un arreglo?
Para que un usuario pueda escribir un elemento en un arreglo, puede hacerlo
asignando el valor directamente al elemento del arreglo, cosa que se hace con
la instrucción “cin>>”
Al inicio tenemos un grupo de 3 huevos rotos mostrando su respectiva valor
(digamos 10, 20 y 30), desde arriba aparece el “cin>>45”. Después, sale un
meteorito y choca contra el tercer huevo, el tercer huevo explota y después
aparece un huevo del mismo color, roto y con el pollito mostrando el valor 45.
O también, ayudándonos con una variable del mismo tipo de dato del arreglo.
Ahí entraría un huevo saltando desde algún lado con un pollito adentro, con un
grupo de huevos q están parados. Del huevito, sale un pollito diciendo al grupo
de huevos (que también tienen adentro un pollito) que busca un “amigo” que
tiene un valor 5. Entonces pregunta al primero, ¿tienes el valor 5?, el pollito del
primer huevo del grupo dice que no, entonces el pollito se mete en el huevo,
con todo y huevo salta al pollito que está en el segundo huevo del grupo y le
pregunta lo mismo, éste le dice q no, pero va al tercero y éste le dice que sí,
entonces el pollito le dice “ te regalo este cartel porque tengo varios en mi casa”
(basado en la animación anterior que para mostrar un valor, sale un pollito con
un cartel)
3.4 Ejercicio
El juego de entrar longitud de filas y columnas y que después muestra los
huevos con los valores insertados (el juego ya está hecho)
4 Declaración de un arreglo
4.1 Sintaxis
Para empezar a utilizar un arreglo, debemos tener en cuenta 2 pasos básicos:
1. Declaración: Indicar que hay un arreglo de algún nombre y de alguna
longitud.
2. Inicialización: Darle valores a cada elemento del arreglo
La idea aquí es crear una animación sencilla que muestra los mensajes paso a
paso, es decir que cuando diga “Para empezar a utilizar un arreglo, debemos
tener en cuenta 2 pasos básicos” se muestre la frase y desaparezca, para
después mostrar “1.Declaración: Indicar que hay un arreglo de algún nombre y
de alguna longitud” con una animación asociada (que abajo se explica). Ya
cuando se muestra la frase y termina la animación, estas dos desaparecen y
aparece la frase “2.Inicialización: Darle valores a cada elemento del arreglo”
con su animación.
En cuanto a la animación y las frases:
 En: “1.Declaración: Indicar que hay un arreglo de algún nombre y de
alguna longitud”, se crearía una cantidad de huevos con su respectiva
cajita y se le incitaría al usuario a que ponga el puntero de mouse sobre
los huevos los cuales no se romperían.
Coloca el puntero del
mouse sobre cualquier
huevo y verás q no pasa
nada
 En “2. Inicialización: Darle valores a cada elemento del arreglo”, se haría
el vuelo de una cigüeña que botaría los carteles y cada uno de ellos
caería sobre un huevo. La idea es que al final, se incite al usuario a que
ponga el puntero del mouse sobre los huevos y ahí si cada huevo se
rompa y muestre el valor del cartel que le cayó.
Si el cursor está sobre el primer huevo:
Coloca el puntero
del mouse sobre
cualquier huevo y
verás
que
mostrará algún
valor
Si el cursor está sobre el segundo huevo:
Si el cursor está sobre el tercer huevo:
Si el cursor está sobre el cuarto huevo:
4.2 Inicialización de un arreglo
4.2.1 Por ciclos
Nos podemos ayudar de una sentencia for o while para insertar datos en el
arreglo. Haz clic en los botones que encuentras abajo para ver como se
puede hacer esta labor:
El solo texto y abajo irían los botones.
El botón volver debe apuntar o debe dirigir a la pantalla anterior
(inicialización de un arreglo).
Al hacer clic en “ciclos por for”:
El programa inserta un valor establecido o se lo pedirá al usuario que
puede hacerlo con la instrucción cin>>. Esto se hace por un número de
veces establecido.
El botón volver se devuelve a la pantalla inicialización por arreglos-> ciclos,
que es la pantalla que tiene dos botones, es decir, la pantalla anterior
(inicialización por for, inicialización por while)
(Botón next)
Recuerda que:
 El valor desde donde debe arrancar el for es 0
 El valor donde debe finalizar es n-1, donde n es el número total de
elementos del arreglo
Si es posible, las flechas rojas pueden quedar intermitentes para lograr
más atención del usuario.
Al hacer clic en “ciclos por while”:
El programa inserta un valor establecido o se lo pedirá al usuario que
puede hacerlo con la instrucción cin>>. Esto se hace por un número de
veces.
(Botón next)
Recuerda que:
 La variable controladora del ciclo debe iniciar en cero y ser
aumentada al finalizar el ciclo.

El valor donde debe finalizar es n-1, donde n es el número total de
elementos del arreglo
La idea aquí es animar los textos que aparecen desde el “recuerda que”.
Las flechas verticales deben aparecer apenas salga el texto correspondiente al
primer inciso (“La variable controladora del ciclo…”) y que sean intermitentes
(aparezcan y desaparezcan 3 veces y que después queden fijas).
Luego de que las flechas verticales queden fijas, aparece el texto del segundo
inciso (“El valor donde debe finalizar…”) y las flechas horizontales de forma
intermitente (unas 3 veces que aparezcan y desaparezcan) para después
quedar fijas.
El botón volver debe apuntar o debe dirigir a la pantalla inicialización por
arreglos-> ciclos, que es la pantalla que tiene dos botones (inicialización por
for, inicialización por while)
4.2.2 Lista de inicialización
Consiste en tener un grupo de valores predeterminados los cuales están
guardados entre llaves. Ten cuidado al verificar que el número de valores
del grupo debe ser el mismo que el número de elementos.
Tenemos cuatro carteles y cuatro huevos vacíos. La idea es que se haga
una animación con el primer cartel yendo al primer huevo, el segundo cartel
al segundo huevo, y así sucesivamente. La idea es que al final se muestren
los cuatro huevos con los valores adquiridos.
4.2.3 Por cálculos
Aplicas una fórmula matemática sobre cada posición del arreglo.
4.2.4 Qué pasa si……

¿Pongo más valores de inicio que la longitud del arreglo?
Causaría errores en ejecución ya que no hay lugar en el arreglo para
todos los valores que deseamos asignar. Así que los valores que
sobran se pierden.

¿Pongo menos valores de inicio que la longitud del arreglo?
Las posiciones que quedarían en el arreglo quedan sin valor. Esto
puede variar en algunos lenguajes de programación ya que en
algunos se coloca un valor por default como el 0 o null, y en otros
genera errores de ejecución.
4.3 Ejercicio
5 Matrices
5.1 Cuestiones básicas
Los vectores (que son los tipos de arreglos que hemos visto hasta ahora),
pueden guardar conjuntos de datos del mismo tipo.
Sin embargo, hay otro tipo de arreglos que guardan varias listas de datos del
mismo tipo. A este tipo de arreglos se les llama matriz.
Animación donde se tiene inicialmente una hilera de 3 huevos que se muestran
en la primera frase. Al aparecer la frase “Sin embargo, hay otro tipo…” salen un
par de huevos de los que ya existen para formar un conjunto de huevos de 3
filas por 3 columnas.
(Botón siguiente)
La estructura básica de una matriz es:
 Nombre
 Subíndices: El primero especifica las filas y el otro las columnas.
Recuerda que si tienes un arreglo denotado como matriz [i, j] donde i y j son
subíndices del arreglo, es equivalente a decir matriz[j] ya que se evalúa el
último término de la expresión.
(Botón siguiente)
Para mencionar la longitud de la matriz, se cuenta el número de filas (x) y el
número de columnas (y). De manera que la matriz será de x por y.
y
x
y
x
5.2 Inicialización
Básicamente, las formas de inicializar una matriz son las mismas que las de un
vector (cosa que vimos en el capítulo anterior), con la diferencia de que se
aplica un ciclo más dentro del que ya tenemos. Haz clic sobre las opciones que
encuentras abajo.
5.2.1 Inicialización por ciclos
Consiste en aplicar un ciclo dentro del otro y preguntar por el valor que desea
aplicar. La inserción del dato puede ser un dato fijo o por teclado tal y como lo
vimos en la inicialización de vectores.
5.2.2 Listas de inicialización
Consiste en tener un conjunto de listas de valores determinadas del mismo tipo
de datos. Las listas de datos se deben escribir entre llaves. Haz clic en los
botones que ves abajo para ver las distintas formas de inicialización
5.2.2.1
Inicialización con una sola lista de valores
Consiste en aplicar todos los valores dentro de un solo par de llaves.
El botón volver se devuelve a la pantalla inicialización por matrices->
inicialización por ciclos, que es la pantalla que tiene dos botones, es
decir, la pantalla anterior
(Botón siguiente)
Si hacen falta datos para rellenar la matriz, se les añadirá un valor
cero por defecto a las posiciones faltantes.
El botón volver se devuelve a la pantalla inicialización por matrices->
inicialización por ciclos, que es la pantalla que tiene dos botones
5.2.2.2
Inicialización con varias listas
Consiste en aplicar varias listas de valores dentro de un par de
llaves. Cada lista también debe estar encerrada dentro de un par de
llaves y separadas de las demás por una coma.
El botón volver se devuelve a la pantalla inicialización por matrices->
inicialización por ciclos, que es la pantalla que tiene dos botones
(Botón siguiente)
Si hacen falta datos para rellenar la matriz, se les añadirá un valor
cero por defecto a las posiciones faltantes.
El botón volver se devuelve a la pantalla inicialización por matrices->
inicialización por ciclos, que es la pantalla que tiene dos botones
5.2.3 Por cálculos
Se aplica un ciclo dentro de otro y la asignación se hace por medio de una
fórmula matemática.
Tenemos seis carteles y seis huevos vacíos. La idea es que se haga una
animación con el primer cartel yendo al primer huevo, el segundo cartel al
segundo huevo, y así sucesivamente. Desde el cuarto huevo, se va a la
siguiente fila. La idea es que al final se muestren los seis huevos con los
valores adquiridos.
5.3 ¿Cómo leo en una matriz?
Para que el depurador pueda leer el valor contenido en una posición
determinada de la matriz, basta con que él tenga los subíndices y los límites
sobre los cuales se encuentra el arreglo.
Para que nosotros lo podamos ver, se escribe el comando
“cout<<matriz[num1][num2]” donde matriz es el nombre del arreglo y donde
num1 y num2 son los subíndices.
5.4 ¿Cómo escribo en una matriz?
Para que nosotros podamos escribir un elemento en una matriz, se utiliza la
instrucción “cin>>” en los subíndices donde queramos ubicar el valor.
Ahí entraría un huevo saltando desde algún lado con un pollito adentro, con un
grupo de huevos q están parados. Del huevito, sale un pollito diciendo al grupo
de huevos (que también tienen adentro un pollito) que busca un “amigo” que
tiene un valor 5. El huevo cuyo pollito que tenga el valor preguntado se va a
romper y el pollito saldrá diciendo “Yo lo tengo!!!”, entonces el primer pollito le
tira su cartel y el otro lo recibe
Busco el huevo
1,1….
Aquí estoy!!!
Ahí va!!!
5.5 Ejercicio
6 Ordenamientos
Un ordenamiento consiste en colocar los datos en un orden particular. Por lo
general se aplica en vectores con valores enteros.
6.1 Burbuja
Es un ordenamiento en donde los valores más pequeños “flotan” hacia un
extremo del vector mientras que los valores más grandes “flotan” hacia el otro
extremo. Para ver el procedimiento para organizar los valores de un arreglo de
forma ascendente, haz clic en el botón siguiente.
Aquí el botón volver lo devuelve a uno a la pantalla ordenamientos (gráfica
anterior)
(Botón siguiente)
Nuestro primer paso es crear un ciclo para el número de pasadas y ubicamos
una variable llamada pasada en la primera posición del vector.
El botón volver devuelve a la definición de ordenamiento burbuja, es decir, a la
pantalla anterior.
(Botón siguiente)
El segundo paso es crear otro ciclo, esta vez, para realizar la comparación de
valores y ubicamos una variable llamada bandera en la primera posición del
arreglo.
El botón volver debe devolver la animación al paso 1, es decir, a la pantalla
anterior.
(Botón siguiente)
El tercer paso es comparar el valor que hay en bandera con su vecino. Si el
valor de bandera es mayor a su vecino, hacemos el cambio, si no, no pasa
nada.
(Botón siguiente)
El cuarto paso es ubicar bandera en la siguiente posición del arreglo (cosa que
el ciclo que estamos utilizando lo hace automáticamente).
(Botón siguiente)
¿La nueva posición en donde está bandera es la última del arreglo? Si no es
así, simplemente volvemos a repetir el paso 3 tomando como referencia
bandera y su vecino.
Si es así, esto indica que salimos del ciclo de comparación,
Aumentamos en uno el valor de pasada (ciclo de afuera y se hace
automáticamente con el ciclo que estamos utilizando),
Devolvemos bandera a la primera posición del arreglo,
Volvemos a ejecutar el ciclo de comparaciones hasta que bandera llegue hasta
la última posición del arreglo.
Aquí sería en una animación simular el movimiento de los huevos tal y como se
explica desde el tercer paso hasta que la línea que acompaña a vadera llegue
hasta el final. Algo así como:
En otras palabras, esta animación consiste en comparar el valor del huevo que
está subrayando bandera con el huevo que está al lado: si el valor del huevo
que está subrayando bandera es mayor que el que está al lado, los dos huevos
cambian de posición. Independientemente de que haya cambio o no lo haya,
bandera se va a estar moviendo una posición a la derecha. Si bandera llega
hasta el último huevo, se tiene que devolver hasta el primer huevo y pasada se
mueve hacia el huevo del lado y se repiten las comparaciones y el movimiento
de bandera hasta que pasada y bandera lleguen hasta el último huevo.
Para terminar la ejecución del ordenamiento completamente, haz clic en el
botón play.
6.2 Ejercicio
7 Búsquedas
Las búsquedas son un procedimiento para encontrar un valor clave en un
arreglo (no importa si es vector o matriz). Las opciones que se presentan abajo
son los métodos de búsqueda más reconocidos. Haz clic sobre cualquiera de
ellos.
7.1 Lineal
Consiste en la búsqueda del valor clave en cada una de las posiciones del
arreglo hasta que lo encuentre. Se recomienda utilizar este tipo de búsquedas
sobre arreglos pequeños.
7.2 Binaria
Este tipo de búsquedas se utiliza para arreglos que ya están ordenados.
Consiste en buscar la clave la posición del medio del arreglo. Si lo encuentra,
devuelve el resultado, si no, mira si la clave es mayor o menos que el valor que
se encuentra en la posición del medio del arreglo. Si es mayor, devuelve la
primera mitad del arreglo, si no, devuelve la segunda mitad del arreglo y vuelve
a ubicar la posición del medio de la mitad del arreglo devuelto.
Las pantallas que se muestran a continuación van en una sola animación. El
botón volver nos devuelve hasta la pantalla búsqueda (punto 7)
7.3 Ejercicio
8 Evaluación
Ejercicio: Pasapalabra
A: Conjunto de elementos del mismo tipo de dato que puede ser un vector o
una matriz (Respuesta: Arreglo)
B: Tipo de búsqueda (Respuesta: Binaria)
C: Etapa fundamental del ordenamiento en burbuja (Respuesta: Comparación)
D:
E: Tipo de dato conformado por los números sin su parte decimal (Respuesta:
Entero)
F: Tipo de dato conformado por los números que tienen una parte entera y una
parte decimal (Respuesta: Flotante)
G:
H:
I:
J:
K:
L: Tipo de búsqueda (Respuesta: Lineal)
M: Categoría de los arreglos caracterizado por ser de dos o más dimensiones
(Respuesta: Matrices)
N: Componente de un arreglo (Respuesta: Nombre)
O: Concepto en el que se encuentran el estilo burbuja (Respuesta:
Ordenamiento)
P:
Q:
R:
S:
T:
U:
V: Categoría de los arreglos caracterizado por ser de una sola dimensión
(Respuesta: Vectores)
W:
X:
Y:
Z: