Este documento describe diferentes algoritmos de búsqueda como la búsqueda lineal, binaria y métodos hash. La búsqueda lineal recorre todo el vector de manera secuencial mientras que la búsqueda binaria requiere que los datos estén ordenados y divide el vector a la mitad en cada paso. Los métodos hash transforman las claves en índices para permitir búsquedas rápidas sin ordenar los datos.

1. Algoritmos de Búsquedas
Búsqueda Lineal
Concepción-Talcahuano
Ingeniería en Informática
Análisis de Algoritmos
Nombre Alumno (s): Joaquín Contreras.
Gonzalo Retamal.
Nombre Profesor: Pilar Pardo.
Fecha: 16/04/2014

2. INDICE
Indice................................................................................................... 2
1. Introducción ................................................................................... 3
2. ALGORITMOS DE BÚSQUEDA .................................................... 4
2.1 Búsqueda lineal........................................................................ 4
2.2 Búsqueda binaria ..................................................................... 6
2.3 Búsqueda mediante transformación de claves (Hashing)......... 8
2.3.1 Truncamiento...................................................................... 8
2.3.2 Plegamiento........................................................................ 8
2.3.3 Aritmética modular.............................................................. 9
2.3.4 Mitad cuadrado................................................................... 9
3. conclusión.....................................................................................10

3. Página 3
1. INTRODUCCIÓN
En el siguiente informe se describirán lo tipos de búsqueda de
algoritmo lineal, binaria y método hash.
La búsqueda lineal consiste en ser la más simple de todas, debido a que trabaja
con vectores desordenados buscando desde el primer elemento hasta el último
elemento del vector completo. Siendo eficaz en vectores pequeños y búsquedas
concisas (un elemento concreto).
La búsqueda binaria trabaja en segmentos de manera que divide el vector y
compara el valor a buscar con el lado que lo tenga, en caso de identificar el dato
en ese lado, va descartando el segmento que no necesita y así sucesivamente.
Los métodos hash consisten en transformar claves numéricas y/o alfanuméricas
en direcciones o índices de un vector lo que permite aumentar la búsqueda sin
necesidad de tener los datos ordenados previamente. Existiendo 4 métodos que
son truncamiento, plegamiento, aritmética modular y mitad del cuadrado.

4. Página 4
2. ALGORITMOS DE BÚSQUEDA
2.1 Búsqueda lineal
Esta búsqueda es la más sencilla, busca los elementos del array desde el
primer elemento hasta el último sin necesidad de que se encuentren
ordenados. Cuando se realiza la búsqueda de manera exitosa se emite un
mensaje como “Elemento encontrado” y entrega el índice de la posición del
elemento. Para el caso contrario se entrega un mensaje como “Elemento no
existente”.
Esta búsqueda no requiere ningún requisito por parte del vector, es decir, no
necesita que el vector este ordenado o que sea par o impar, siempre se
realizara la búsqueda de la misma manera.
El único pero de esta búsqueda es que si el array es demasiado grande tomara
demasiado tiempo en recorrerla para realizar las búsquedas.
Mejor Caso:
El mejor caso para una búsqueda lineal es cuando nuestro elemento buscado
se encuentra al comienzo del array con lo que el tiempo y memoria usados
serán las mínimas y se obtendrá un resultado rápido.
Ejemplo:
0 1 2 3 4 5 6
8 7 17 81 12 99 35
Se busca el elemento “8”
Recorrido de búsqueda:
1.- índice 0 = 8, elemento encontrado, fin de la búsqueda.

5. Página 5
Peor Caso:
Este caso de búsqueda es cuando el elemento buscado se encuentra en la
última posición del array o que no exista, por tanto se utiliza más tiempo y
memoria para su ejecución.
Ejemplo:
0 1 …. 8 …. 40
40 12 …. 83 …. 77
Se busca elemento “77”
Recorrido de búsqueda:
1. Índice 0 ≠ 77
2. Índice 1 ≠ 77
3. …
4. Índice 8 ≠ 77
5. …
6. Índice 40 = 77, Elemento existe, fin de la búsqueda en el índice 40.
Caso Promedio:
Esto ocurre cuando el elemento a buscar esta en el medio de la array.
Ejemplo:
0 1 2 3 4 5 6
33 21 12 19 73 61 15
Se busca elemento “19”
Recorrido de Busqueda:
1.- Indice 0 ≠ 19
2.- Indice 1 ≠ 19
3.- Indice 2 ≠ 19
4.- Indice 3 = 19, termina la búsqueda en la mitad de la raid.

6. Página 6
2.2 Búsqueda binaria
La mejor forma de definir esta búsqueda es con el concepto “Divide y Vencerás”,
ya que la búsqueda binaria se utiliza en arrays unidimensionales los cuales se van
dividiendo en partes iguales.
Esta búsqueda a diferencia de la linear necesita que los datos estén ordenados.
Procedimiento
Se ubica en la posición central del vector, se compara el valor de la posición y si
es el valor buscado la búsqueda termina ahí; caso contrario se preguntara si el
elemento a buscar es mayor o menor, si es mayor el elemento se seguirá
buscando en la segunda mitad del vector, si es menor se buscara en la primera
mitad. La mitad del vector que no se utilizara es eliminada.
El proceso se repite hasta que el elemento a buscar es encontrado.
Ejemplo:
Buscar un el elemento “10” dentro de una lista ordenada
2 4 7 10 12 22 23 30 33 41
Realización del procedimiento de dividir el arreglo en mitad y comprar.
Paso 1
2 4 7 10 12 22 23 30 33 41
Paso 2
2 4 7 10 12
Paso 3
7 10 12
Paso 4
10 12
El algoritmo concluye al encontrar el dato buscado (“10”) en el primer elemento de
la lista; en este caso quedando 2 resultados 10 y 12, donde 10 es el primer
elemento de la lista.
Mejor Caso:
Se requiere solo una comparación para encontrar el elemento; el tiempo de
ejecución óptimo no depende de la cantidad de datos que se tenga.
El esfuerzo mínimo es 1.
Caso promedio:

7. Página 7
Nuestro caso promedio es 1/2 log2n.
Peor Caso:
Se realiza la búsqueda binaria progresivamente, disminuye el número de
elementos sobre el que se va realizando la búsqueda. Tas log2n divisiones se
habrá localizado el elemento o se tendrá la seguridad de que no existe.
El esfuerzo máximo es log2n.

8. Página 8
2.3 Búsqueda mediante transformación de claves
(Hashing)
Consiste en transformar claves numéricas y/o alfanuméricas en direcciones o
índices de un vector lo que permite aumentar la búsqueda sin necesidad de tener
los datos ordenados previamente.
Existen 4 métodos de transformación de claves:
- Truncamiento
- Plegamiento
- Aritmética Modular
- Mitad del cuadrado
2.3.1 Truncamiento
Ignora parte de la clave y se utiliza la parte restante directamente como índice.
Ejemplo: Claves de 8 dígitos (números enteros) y la tabla de transformación posee
mil posiciones, para el índice se considera el primer, segundo y quinto dígito
formando así la función.
Clave: 89512327 → h(clave) = 892
2.3.2 Plegamiento
Esta técnica se basa en dividir la clave en diferentes partes y la combinación
de las partes en un modo conveniente para obtener el índice.
La clave se divide en varias partes n1, n2, n3,….n∞, donde cada parte tiene el
mismo número de dígitos que la dirección especificada (con la única posibilidad de
excepción de la última parte).
H(x)= n1 + n2 + n3 +…+ x∞
Ejemplo.
El número de identificación de los empleados es el campo clave de una empresa y
consta de cuatro dígitos y las direcciones reales son 100. Se desea calcular las
direcciones correspondientes por el método de plegamiento.
Claves: 2250, 1935, 3144

9. Página 9
H(2250) = 22 + 50 = 72
H(1935) = 19 + 35 = 54
H(3144) = 31 + 44 = 7
2.3.3 Aritmética modular
Este método convierte la clave a un entero, se divide por el tamaño del rango
del índice y toma el resto como resultado. La función que se utiliza es el MOD
(módulo o resto de la división entera).
H(x)= x MOD m
Se tiene la clave=234661234 MOD 101 = 56
234661234 MOD 101 = 56
2.3.4 Mitad cuadrado
Este método calcula el cuadrado de la clave que se posee (x).
La función de conversión se define como: H(x)=c
Donde c se obtiene eliminando dígitos a ambos lados de x²
Ejemplo:
En una empresa hay 80 empleados, cada uno tiene un número de identificación de
4 dígitos y las direcciones de memoria van de 0 a 100.
x → 5120
x² → 26214400; Por lo tanto H(x) = 14

10. Página
10
3. CONCLUSIÓN
Este método de búsqueda sirve para los array (vectores) pequeños ya que
en los array de mayor tamaño el consumo de recursos se intensifica y el tiempo se
va alargando mucho más si el elemento a buscar está en la última posición (peor
caso). Recomendable para los sistemas pequeños (empotrados) o redes locales
pequeñas.