Este documento presenta el algoritmo de búsqueda binaria. Explica cómo funciona dividiendo repetidamente el arreglo en mitades hasta encontrar el elemento buscado, lo que permite realizar la búsqueda de forma muy eficiente, en un número de pasos logarítmicos respecto al tamaño del arreglo. Incluye ejemplos del algoritmo implementado en lenguajes como C++, Visual Basic y Java, mostrando cómo aplicar la búsqueda binaria para encontrar un número de cédula dentro de un arreglo ordenado.

1. UNIVERSIDAD CENTRAL DE ECUADOR
FACULTAD DE INGENIERÍA CIENCIAS FÍSICAS Y MATEMÁTICA
PROGRAMACIÓN I
DOCENTE: ING. WAGNER LUCERO
TEMA: BÚSQUEDA BINARIA
INTEGRANTES:
CARLOS DELGADO
JESSICA ALBARRÁN
ANDRES FONSECA
MISHEL ARGUELLO PINZÓN
ARACELY MONTALUISA
MISHELL CHUGÁ
PARALELO: 10
SEMESTRE: PRIMERO
CURSO: 2014-2015

2. Contenido
INFORME TÉCNICO......................................................................................................................1
OBJETIVO GENERAL.....................................................................................................................1
OBJETIVOS ESPECÍFICOS..............................................................................................................1
PRESENTACION DEL PROYECTO..................................................................................................1
INTRODUCCIÓN ...........................................................................................................................2
DESARROLLO ...............................................................................................................................3
FUNCIONALIDAD DEL ALGORÍTMO DE BUSQUEDA BINARIA....................................................4
EJERCICIO DEL ALGORITMO DE BÚSQUEDA BINARIA................................................................5
EJEMPLO DE ALGORITMOS DE BUSQUEDA BINARIA................................................................6
C++............................................................................................................................................6
VISUAL BASIC...........................................................................................................................11
EJEMPLO DE BUSQUEDA EN JAVA..................................................................................14
VENTAJAS Y DESVENTAJAS.......................................................................................................20
PROGRAMA PARA EL VIDEO.....................................................................................................20
CONCLUSIONES..........................................................................................................................21
RECOMENDACIONES.................................................................................................................22
BIBLIOGRAFIA............................................................................................................................23

3. 1
INFORME TÉCNICO
Tema: Búsqueda binaria
OBJETIVO GENERAL
Explicar la lógica de una búsqueda binaria en un arreglo unidimensional
OBJETIVOS ESPECÍFICOS
Definir que es un algoritmo de búsqueda.
Dar a conocer cómo funciona el algoritmo de búsqueda binaria.
Mostrar un ejercicio para mejor comprensión del mismo.
Describir las ventajas y desventajas de un algoritmo de búsqueda binaria.
Realizar una búsqueda binaria en los lenguajes de programación Visual Basic, C++, java.
PRESENTACION DEL PROYECTO
Para la presentación de nuestro tema, hemos decidido hacerlo en dos diferentes programas como
son: Power Point y Prezi, los mismos que permiten una mejor forma de presentar un tema, de
una manera más organizada, lo que hace que estos dos programas se conviertan en perfectos para
una buena presentación.
Con respecto al video será manejado cuidadosamente con el programa Bandicam que resulta ser
el más eficiente para realizar la grabación de la PC.

4. 2
INTRODUCCIÓN
Cuando deseamos encontrar cierta información en un arreglo o vector unidimensional
como el número de cedula de un ciudadano en una base de datos grande, demos utilizar
métodos de búsqueda que faciliten nuestro trabajo, pero ahorrando recursos. Esto quiere
decir que si en una base de datos de miles de usuarios no podemos buscar uno por uno
porque gastamos tiempo y dinero.
El método de búsqueda que da a conocer en este informe es el método de búsqueda
binario que es de alta velocidad y eficiente.
Se le da el nombre de búsqueda binaria porque el algoritmo divide en dos el arreglo,
aludiendo al concepto de bit, el cual puede tener dos estados. Está altamente recomendado
para buscar en arreglos de gran tamaño. La única condición para usar este algoritmo es que
los datos dentro del arreglo estén ordenados de menor a mayor.

5. 3
DESARROLLO
El algoritmo de búsqueda binaria elimina, tras cada comparación, la mitad de los
elementos del arreglo en los que se efectúa la búsqueda. Primero localiza el elemento central
del arreglo y luego lo compara con la clave de búsqueda. Si son iguales, se ha encontrado
dicha clave y se devuelve el subíndice de ese elemento, de otro modo, el problema se reduce
a buscar en una mitad del arreglo. Si la clave de búsqueda es menor que el elemento central
del arreglo, se busca en la primera mitad; de otro modo se busaca en la segunda mitad. Si la
clave de búsqueda no está en el elemento central del sub-arreglo especificado (parte del
arreglo original), se repite el algoritmo en una cuarte parte del arreglo original. La búsqueda
continua hasta que la clave de búsqueda sea igual al elemento, el cual no es igual a la clave
de búsqueda (es decir, no se encuentra la clave de búsqueda).
En el peor caso, la búsqueda en un arreglo de 1024 elementos solo llevara 10
comparaciones mediante la búsqueda binaria. La división repetida de 1024 entre 2 (dado que
tras cada comparación se puede descartar la mitad del arreglo) nos da los valores 512, 256,
128, 64, 32, 16, 8, 4, 2 y 1. El numero 1024 (2^10) se divide entre dos diez veces para llegar
al valor 1. La división entre 2 es equivalente a una comparación en el algoritmo de búsqueda
binaria. Un arreglo de 10488576 (2^20) elementos tarda un máximo de 20 comparaciones
en encontrar la clave de búsqueda. Un arreglo de mil millones de elementos necesita un
máximo de 30 comparaciones. Esta es una mejora enorme en relación con la búsqueda lineal,
que requería comparar la clave de búsqueda con un promedio de la mitad de los elementos

6. 4
del arreglo. ¡Para un arreglo de mil millones de elementos, esta diferencia es entre un
promedio de 500 millones de comparaciones y un máximo de 30! La cantidad máxima de
comparaciones necesarias para la búsqueda binaria de cualquier arreglo ordenado puede
determinarse encontrando la primera potencia de 2 mayor que el número de elementos del
arreglo.
FUNCIONALIDAD DEL ALGORÍTMO DE BUSQUEDA BINARIA
1. Se declaran los índices superior e inferior. El inferior que inicia en cero y el superior con el
tamaño del arreglo menos 1.
2. Se calcula el centro del arreglo con la siguiente fórmula. Centro= (inferior + superior) / 2.
3. Se verifica si el arreglo en la posición centro es igual al dato o elemento que se desea
encontrar. Si es igual significa que encontramos el elemento y retornamos centro.
4. Debido a que el vector se encuentra ordenado si el dato que buscamos es mayor a la posición
central se descartan todos los datos que se encuentren en la parte inferior, ahora la variable inicio
se ubica en la posición centro + 1 de la misma manera si el dato que buscamos en menor que
la posición central definida se descarta la parte superior del vector, ahora la variable final se
moverá a la izquierda y se ubica en la posición centro – 1.
5. Volvemos al paso 2, hasta encontrar el dato que buscamos.

7. 5
EJERCICIO DEL ALGORITMO DE BÚSQUEDA BINARIA
Se quiere buscar el 10 en el siguiente arreglo:
Paso 1:
La búsqueda binaria busca la mitad del arreglo: Es decir toma las posiciones inicial y final del
arreglo para obtener el centro Centro = (0 + 9)/2 Centro = 4,5 Tomamos la parte entera que seria
4.
Ahora se realiza una comparación del número 21 con el número buscado.
21 < 10 no 21 > 10 si
Esto quiere decir que el número que buscamos se encuentra al lado izquierdo del 21 y se
descartan todos los elementos ubicados al lado derecho por ser mayores que el número que
buscamos. Ahora la variable pos_fin se ubica en la posición anterior 21 que sería el 15, de esta
manera se define un nuevo intervalo.
Nuevamente se repite el procedimiento Centro = (0 + 3)/2 Centro = 1,5 Tomo la parte entera que
seria 1

8. 6
Ahora se realiza una comparación del número 5 con el número buscado.
5 < 10 si 5 >10 no
Esto quiere decir que el número que buscamos se encuentra al lado derecho del 5 y se descartan
el número 3 por ser menor al número que buscamos. Ahora la variable pos_ini se ubica en la
posición siguiente del número 5 que sería el 10. Se define un nuevo intervalo. Nuevamente se
repite el mismo proceso. Centro = (2 + 3)/2 Centro = 2,5 entonces tomamos el 2 y comparamos
10<15 si ; se descarta el 15 y la variable pos_fin se mueve a la izquierda tomando el mismo valor
que pos_ini entonces tenemos pos_ini = pos_fin.
Centro= (2 + 2)/2; esto nos da 2 que sería la posición del número buscado.
EJEMPLO DE ALGORITMOS DE BUSQUEDA BINARIA
C++
La búsqueda binaria sólo se puede implementar si el arreglo está ordenado. La idea consiste en ir
dividiendo el arreglo en mitades. Por ejemplo supongamos que tenemos este vector:
int vector[10] = {2,4,6,8,10,12,14,16,18,20};
La clave que queremos buscar es 6. El algoritmo funciona de la siguiente manera.
Se determinan un índice arriba y un índice abajo, Iarriba=0 e Iabajo=9 respectivamente.
Se determina un índice central, Icentro = (Iarriba + Iabajo)/2, en este caso quedaría Icentro = 4.

9. 7
Evaluamos si vector[Icentro] es igual a la clave de busqueda, si es igual ya encontramos la clave
y devolvemos Icentro.
Si son distintos, evaluamos si vector[Icentro] es mayor o menos que la clave, como el arreglo
está ordenado al hacer esto ya podemos descartar una mitad del arreglo asegurándonos que en
esa mitad no está la clave que buscamos. En nuestro caso vector[Icentro] = 4 < 6, entonces la
parte del arreglo vector[0...4] ya puede descartarse.
Reasignamos Iarriba o Iabajo para obtener la nueva parte del arreglo en donde queremos buscar.
Iarriba, queda igual ya que sigue siendo el tope. Iabajo lo tenemos subir hasta 5, entonces
quedaría Iarriba = 9, Iabajo = 5. Y volvemos al paso 2.
Si la clave no fuese encontrada en algun momento Iabajo > Iarriba, con un while vamos a
controlar esta condición para salir del ciclo en tal caso y devolver -1 (clave no encontrada).
//Busqueda binaria
//en un arreglo.
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void mostrarArreglo(const int[], int); //prototipo de funcion que
//recibe un arreglo constante

10. 8
int busquedaBinaria(const int[], int, int); //arreglo, tamano, clave
void ordenarArreglo(int[], int); //prototipo que modifica y ordena el
//arreglo
void intercambiar(int&, int&); //prototipo, intercambia
//los valores de dos elementos
int main()
{
int clave =0;
const int tamano = 15;
int arreglo[tamano] = {25,17,13,16,41,32,12,115,95,84,54,63,78,21,10};
//ordenamos el arreglo para que funcione la busquedaBinaria
ordenarArreglo(arreglo,tamano);
cout << "Elementos del arreglo: " << endl;
mostrarArreglo(arreglo,tamano);
cout << "Indique un valor a buscar y se le devolvera el indice: " << endl;
cin >> clave;
cout<< "Su valor se encuentra en arreglo["<<busquedaBinaria(arreglo,tamano,clave)<<"]" <<
endl;

11. 9
cout << "Fin del programa :)" << endl;
return 0;
}//fin de main
void mostrarArreglo(const int arreglo[], int tamano)
{
for (int i = 0 ; i < tamano ; i++)
cout << "arreglo[" << i << "]=" << arreglo[i] << endl;
}
int busquedaBinaria(const int arreglo[], int tamano, int clave)
{
int Iarriba = tamano-1;
int Iabajo = 0;
int Icentro;
while (Iabajo <= Iarriba)
{
Icentro = (Iarriba + Iabajo)/2;
if (arreglo[Icentro] == clave)

12. 10
return Icentro;
else
if (clave < arreglo[Icentro])
Iarriba=Icentro-1;
else
Iabajo=Icentro+1;
}
return -1;
}
void ordenarArreglo(int arreglo[], int tamano)
{
for (int i = 0; i< tamano -1 ; i++)
for (int j = 0; j< tamano -1 ; j++)
if (arreglo[j] > arreglo[j+1])
intercambiar(arreglo[j],arreglo[j+1]);
}
void intercambiar(int &a, int &b)

13. 11
{
int tmp = b;
b = a;
a = tmp;
}
VISUAL BASIC
Sub cedula()
Dim i, j, inicial, final As Integer
Dim central, dimension As Integer
Dim aux, cedula(10000), buscado As Long
dimension = InputBox("Ingrese la cantidad de registrados")

14. 12
For i = 0 To dimension - 1
cedula(i) = Int((1899999999 - 1111111111) * Rnd + 1111111111)
Worksheets("Hoja1").Cells(i + 1, 1).Value = cedula(i)
Next i
For j = 0 To dimension - 1
For i = 0 To dimension - 2
If (cedula(i) > cedula(i + 1)) Then
aux = cedula(i)
cedula(i) = cedula(i + 1)
cedula(i + 1) = aux
End If
Next i
Next j
For i = 0 To dimension - 1

15. 13
Worksheets("Hoja1").Cells(i + 1, 3).Value = cedula(i)
Next i
final = dimension - 1
inicial = 0
buscado = InputBox("Ingrese el numero de cedula que desea encontrar")
While (inicial <= final)
central = Int((final - inicial) / 2)
If (cedula(central) = buscado) Then
MsgBox ("Dato encontrado entre la fila " & central + 1 & " y columna C")
inicial = final + 1
Else
If (buscado < cedula(central)) Then
final = central - 1
Else
inicial = central + 1

16. 14
End If
End If
Wend
End Sub
En el ejemplo anterior, se genera números aleatorios que supuestamente son números de cédula
utilizados para el ejemplo. Luego se los ordena de menor a mayor y se los imprime el hoja de
Excel. Aquí es donde se realiza la búsqueda binaria, buscando el número de cedula que el
usuario desea hallar.
EJEMPLO DE BUSQUEDA EN JAVA
CON RELACION AL EJEMPLO DE LA CEDULA DE VISUL BASIC
public class Deber18 {

17. 15
public static int busquedaBinaria (int cedula[], int buscado) {
int inicio=0;
int fin=cedula.length-1;
int pos;
while(inicio<=fin)
{
pos=(inicio+fin)/2;
if(cedula[pos]==buscado)
{
return pos;
}
else
{
if(cedula[pos]<buscado)
{

18. 16
inicio=pos+1;
}
else
{
fin=pos-1;
}
}
}
return -1;
}
public static void main(String[] args) {
Scanner dato=new Scanner(System.in);
int []cedula=new int [10];

19. 17
int buscado, aux;
Random rnd = new Random();
for(int i=0;i<cedula.length;i++)
{
cedula[i] = rnd.nextInt(1899999999- 1111111111 + 1) + 1;
}
for(int i=0;i<cedula.length-2;i++)
{
for(int j=i+1;j<cedula.length-1+0;j++)
{
if (cedula[i]>cedula[j])
{
aux=cedula[i];
cedula[i]=cedula[j];
cedula[j]=aux;
}

20. 18
}
}
for( int i=0;i<cedula.length;i++)
{
System.out.println(cedula[i]);
}
for(int i=0;i<cedula.length;i++)
System .out.println("cedulas["+i+"]:"+cedula[i]);
System.out.println ("ingrese el dato que desea encontara");
buscado=dato.nextInt();
int resultado=Deber18.busquedaBinaria(cedula,buscado);
System.out.println(busquedaBinaria(cedula, resultado));
if(resultado!=-1)
{
System.out.println("Encontrado en: "+resultado);

21. 19
}
else
{
System.out.println("El dato no se encuentra en el arreglo no esta ordenado.");
}
}
}

22. 20
VENTAJAS Y DESVENTAJAS
La búsqueda binaria es un método eficiente siempre y cuando el arreglo este ordenado de manera
ascendente y descendente.
La búsqueda binaria proporciona un medio para reducir al máximo el tiempo necesario para
buscar un elemento dentro de una lista de gran tamaño.
Esta altamente recomendado para buscar en arreglos extremadamente extensos ya que si se tiene
un arreglo de más 100 elementos, este en una sola iteración desecha la mitad del arreglo
reduciendo elementos y de esta manera tiempo.
El arreglo debe estar necesariamente ordenado de manera ascendente.
PROGRAMA PARA EL VIDEO
Utilizaremos Bandicam ya que es una aplicación que nos ayuda a grabar en vídeo todo lo que
está sucediendo a través de la pantalla de nuestro ordenador, convirtiéndose en una herramienta
muy funcional que nos permite crear Gameplays o videotutoriales de nuestros programas o
videojuegos favoritos.
La versión Bandicam 2.1.2.740 es la más actualizada dispone de un formato de compresión
único, que se encarga de comprimir toda la información almacenada en los vídeos que creemos,
lo que ayuda a reducir el su tamaño, y resultando una opción ideal para subir directamente los
videos a YouTube.

23. 21
CONCLUSIONES
El método de búsqueda binaria se encarga de examinar primero el elemento central de la lista; si
este es el elemento buscado entonces la búsqueda ha terminado. El tipo de búsqueda binaria se
utiliza en vectores ordenados.
Es por eso que luego de realizar este trabajo hemos visto como los algoritmos son una de las
herramientas más complejas y aplicables en el área de la informática y el mundo de los
computadores.
Las técnicas de desarrollo de algoritmos nos permiten encontrar la mejor solución a los
problemas que se nos presentan y deben ser solucionados por el computador y nuestro
razonamiento, estas técnicas están orientadas para utilizarse en cada uno de los niveles de
complejidad y variedad o alternativas para las cuales se aplican los algoritmos.

24. 22
RECOMENDACIONES
Antes de realizar una búsqueda empleando el algoritmo binario se debe verificar que es arreglo
este ordenado de manera ascendente y descendente.
Utilizar un algoritmo de búsqueda de acuerdo a sus necesidades para una mejor eficiencia en la
búsqueda de elementos y procesamiento de la misma.
Es recomendable utilizar este método de búsqueda con archivos muy extensos ya que
proporciona un medio para reducir el tiempo de búsqueda, debido a que en una sola iteración
elimina el 50 % de elementos de una lista o arreglo que se está ejecutando.

25. 23
BIBLIOGRAFIA
Joyanes, L. (2013). Fundamentos de programación, Algoritmos, estructura de datos y objetos.
España: McGraw – Hill
LOZANO, Letvin.(2013) Diagramación y Programación. Tercera Edición. Editorial: McGraw-
Hill. Madrid, España. 18, 19 páginas.
Y. Langsam, M. J. Augenstein, A. Tenenbaum. Data Structures using C and C++ Prentice Hall,
Second edition. ISBN 0-13-036997-7.