Está en la página 1de 80

1

Estructura de datos
José Oswaldo Guamán Quinche
Facultad de la Energía, las Industrias y los Recursos Naturales No
Renovables
Carrera de Ingeniería en Sistemas/Computación
Investigación en Tecnologías de la Información y Comunicación

Junio, 2021
Loja, Ecuador
Índice
• Ordenación directa
– Burbuja
– Selección
– Inserción
• Ordenación indirecta
– Shell
– Quicksort
• Por mezcla
– Búsqueda secuencial
– Búsqueda binaria
– Búsqueda mediante transformación de claves
Ordenación, Clasificación

• Introducción

• Algoritmos

• Complejidad

4
Introducción

• Ordenación o clasificación es el proceso de


reordenar un conjunto de objetos en un orden
específico. El propósito de la ordenación es
facilitar la búsqueda de elementos en el conjunto
ordenado.
• Existen muchos algoritmos de ordenación, siendo
la diferencia entre ellos las ventajas de unos sobre
otros en la eficiencia en tiempo de ejecución.

5
Introducción

• Los métodos de ordenación se pueden clasificar en


dos categorías:
– ordenación de ficheros y
– ordenación de arrays.
También suele llamarse ordenamiento externo e
interno, debido a que los ficheros se guardan en
la memoria externa (lenta) mientras que los
arrays se almacenan en la memoria rápida del
ordenador (interna). En esta sección sólo se
aborda el ordenamiento interno.
6
Introducción

• El problema del ordenamiento puede establecerse


mediante la siguiente ación:
Dados los elementos: a1 ,a2 , , an
Ordenar consiste en permutar esos elementos en
un orden: ak1 ,ak 2 , , ak n
tal que dada una función de ordenamiento f:
f (ak1 ) f (ak 2 )   f ( akn )

7
Introducción
• Normalmente, la función de ordenamiento no es
evaluada de acuerdo a una regla de computación
determinada, pero se guarda como un componente
explícito (campo) de cada item (elemento). El valor de
ese campo se llama la llave del item.
• Un método de ordenamiento es estable si el orden
relativo de elementos con igual llave permanece
inalterado por el proceso de ordenamiento.
• Se entiende que los métodos de ordenamiento buscan
un uso eficiente de la memoria por lo que las
permutaciones de elementos se hará in situ, es decir,
usando el mismo contenedor original.
8
Introducción

• En lo que sigue se considera que la estructura


lineal (array, lista, vector o secuencia) a ordenar se
representa por un array de objetos (números
enteros):
int a[ ] = new int[MAX];
• siendo MAX el número máximo de elementos del
array. El orden de los elementos después de la
ordenación se considera ascendente.

9
Algoritmo burbuja

• Es un método caracterizado por la comparación e


intercambio de pares de elementos hasta que todos
los elementos estén ordenados.
• En cada iteración se coloca el elemento más
pequeño (orden ascendente) en su lugar correcto,
cambiándose además la posición de los demás
elementos del array.

10
Algoritmo burbuja

for(i=n;i>0;i--)
for(j=0;j<i-1;j++)
if (a[j] > a[j+1])
{
t=a[j];
a[j] = a[j+1];
a[j+1]=t;
ninterc++;
}
11
// Definimos una función donde A=arreglo y N=tamaño
int bubblesort(int A[],int N){
int i,j,AUX;
for(i=2;i<=N;i++){ //siguiente
for(j=N;j>=i;j--){ //anterior
if(A[j-1]>A[j]){ //si i > d intercambio
AUX=A[j-1]; //guardamos en AUX
A[j-1]=A[j]; //pasamos d a i
A[j]=AUX; //copiamos AUX en d
}
}
}
return 1;
}
Algoritmo burbuja

Datos
originales 1ª iter. 2ª 3ª 4ª
36 6 6 6 6
24 36 10 10 10
10 24 36 12 12
6 10 24 36 24
12 12 12 24 36

13
Algoritmo burbuja

Datos
originales 1ª iter. 2ª 3ª 4ª
36 6 6 6 6
24 36 10 10 10
10 24 36 12 12
6 10 24 36 24
12 12 12 24 36

14
Algoritmo burbuja

Datos
originales 1ª iter. 2ª 3ª 4ª
36 6 6 6 6
24 36 10 10 10
10 24 36 12 12
6 10 24 36 24
12 12 12 24 36

15
Algoritmo burbuja

Datos
originales 1ª iter. 2ª 3ª 4ª
36 6 6 6 6
24 36 10 10 10
10 24 36 12 12
6 10 24 36 24
12 12 12 24 36

16
Algoritmo burbuja

Datos
originales 1ª iter. 2ª 3ª 4ª
36 6 6 6 6
24 36 10 10 10
10 24 36 12 12
6 10 24 36 24
12 12 12 24 36

17
Algoritmo sacudida (shakesort)

• Es una mejora del algoritmo de burbuja en el que


se registra la ocurrencia de un intercambio y el
índice del último intercambio y se alterna la
dirección de las pasadas consecutivas. Con ello
una burbuja liviana en el lado “pesado” y una
pesada en el lado “liviano” quedarán en orden en
una pasada simple.

18
Algoritmo sacudida (shakesort)
l=1; r=n-1; k=n-1; l=k+1;
do for(j=l; j<=r; j++)
{ if (a[j-1]>a[j])
for(j=r; j>=l; j--) {
if (a[j-1]>a[j]) t=a[j-1];
{ a[j-1] = a[j];
t=a[j-1]; a[j]=t;
a[j-1] = a[j]; k=j;
a[j]=t; ninterc++;
k=j; }
ninterc++; r=k-1;
} }
while (l<r); 19
Algoritmo inserción

• Este método es usado por los jugadores de cartas.


Los elementos están divididos conceptualmente en
una secuencia destino y una secuencia fuente . En
cada paso, comenzando con i=2 e incrementando i
en uno, el elemento i-ésimo de la secuencia fuente
se toma y se transfiere a la secuencia destino
insertándolo en el lugar adecuado.
• En otras palabras, en el i-ésimo paso insertamos el
i-ésimo elemento a[i] en su lugar correcto entre
a[1], a[2],…., a[i-1], que fueron colocados en
orden previamente.
20
El algoritmo en pseudocódigo

algoritmo insertSort( A : lista de elementos


ordenables )
para i=1 hasta longitud(A) hacer
index=A[i]
j=i-1
mientras j>=0 y A[j]>index hacer
A[j+1] = A[j]
j=j-1
fin mientras
A[j+1] = index
fin para
fin algoritmo
Algoritmo inserción
for(i=1;i<n;i++)
{
j=i-1;
t=a[i];
while (j>=0 && t<a[j])
{
a[j+1] = a[j];
j=j-1;
}
a[j+1]=t;
}
22
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
23
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
24
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
25
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
26
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
27
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
28
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
29
Algoritmo inserción
Array
original: 44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
30
Algoritmo selección

• En éste método, en el i-ésimo paso seleccionamos


el elemento con la llave de menor valor, entre a[i],
…, a[n] y lo intercambiamos con a[i]. Como
resultado, después de i pasadas, el i-ésimo
elemento menor ocupará a[1],…, a[i] en el lugar
ordenado.

31
Algoritmo selección
for(i=0;i<n-1;i++)
{
k=i;
t=a[i];
for (j=i+1; j<n; j++)
{
if (a[j] < t)
{
t= a[j];
k=j;
}
a[k]= a[i];
a[i]= t;
}
} 32
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
33
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
34
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
35
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
36
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
37
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
38
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
39
Algoritmo selección
Array
original: 44 55 12 42 94 18 06 67
i=2 06 55 12 42 94 18 44 67
i=3 06 12 55 42 94 18 44 67
i=4 06 12 18 42 94 55 44 67
i=5 06 12 18 42 94 55 44 67
i=6 06 12 18 42 44 55 94 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
40
Algoritmo rápido (Quicksort)
• La ordenación rápida se basa en el hecho que los
intercambios deben ser realizados preferentemente
sobre distancias grandes.
• El algoritmo a seguir es el mismo que se aplica
cuando se quiere ordenar un gran montón de
exámenes:
– Seleccionar un valor de división (L por ejemplo) y
dividir el montón en dos pilas, A-L y M-Z. Después se
toma la primera pila y se subdivide en dos, A-F y G-L
por ejemplo. A su vez la pila A-F puede subdividirse
en A-C y D-F. Este proceso continúa hasta que las
pilas sean suficientemente pequeñas para ordenarlas
fácilmente. El mismo proceso se aplica a la otra pila. 41
Algoritmo rápido (Quicksort)

• En este caso se toma un elemento x del array (el


del medio por ejemplo), se busca en el array desde
la izquierda hasta que >x, lo mismo se hace desde
la derecha hasta encontrar <x.
• Después se intercambia esos elementos y se
continúa ese proceso hasta que los índices se
encuentren en la mitad del array. Se aplica el
mismo proceso para la porción izquierda del array
entre el extremo izquierdo y el índice derecho y
para la porción derecha entre el extremo derecho y
el último índice izquierdo.
42
Algoritmo rápido (Quicksort)
• Descripción del algoritmo:
1) Dividir : Si la secuencia S tiene 2 o más elementos,
seleccionar un elemento x de S como pivote. Cualquier
elemento arbitrario, como el último, puede servir. Elimiar los
elementos de S dividiéndolos en 3 secuencias:
L, contiene los elementos de S menores que x
E, contiene los elementos de S iguales a x
G, contiene los elementos de S mayores que x
2) Recursión: De forma recursiva ordenar L y G
3) Vencer: Finalmente, colocar nuevamente los elementos en S
en orden, primero insertar los elementos de L, después E, y
los elementos de G.

43
Algoritmo rápido (Quicksort)
void qsort(int izq, int der, for (i=izq+1;i<=der;i++)
int a[]) if (a[i] < a[izq])
{ {
int i, ult, m, tmp; tmp= a[++ult];
a[ult]= a[i];
if (izq >= der) a[i]=tmp;
return; }
tmp= a[izq]; tmp= a[izq];
m= (izq+der)/2; a[izq]= a[ult];
a[izq]= a[m]; a[ult]=tmp;
a[m]=tmp; qsort(izq,ult-1,a);
ult=izq; qsort(ult+1,der,a);
}
44
Idea de Quick Sort

1) Selección: tomar un elemento

2) Dividir: reordenar los elementos


tal que x va a su posición final E

3) Recursión y Vencer: ordenar


recursivamente

45
Arbol Quicksort

46
Arbol Quicksort

47
Arbol Quicksort

48
Arbol Quicksort

49
Arbol Quicksort

50
Arbol Quicksort

51
Arbol Quicksort

52
Arbol Quicksort

53
Arbol Quicksort

54
Arbol Quicksort

55
Arbol Quicksort

56
Arbol Quicksort

57
... Arbol Quicksort (final)

58
Quicksort In-Place
Paso Dividir: l recorre la secuencia desde la izquierda, y r desde la
derecha

Se realiza un intercambio cuando l está en un elemento mayor que el


pivote y r está en uno menor al pivote.

59
In Place Quick Sort (contd.)

Un intercambio con el pivote completa el paso dividir cuando r < l

60
Ordenación directa por base (radix sort)
• A diferencia de otros métodos, radix sort considera la
estructura de las llaves.
• Se asume que las llaves están representadas en un
sistema de numeración M (M=radix), e.g., si M=2, las
llaves están representadas en binario.
• Toma ventaja de la posición de cada dígito individual
en la clave. Hay dos versiones de la ordenación radix:
MSD (most significant digit), LSD (least significant
digit).
• La ordenación se realiza comparando los bits en cada
posición.

61
Ejemplo Radix sort
Conjunto a ordenar: { 33, 60, 5, 15, 25, 12, 45, 70, 35, 7}
frente cola
cola_digitos[0] 60 70
cola_digitos[1]
cola_digitos[2] 12
cola_digitos[3] 33
cola_digitos[4]
cola_digitos[5] 5 15 25 45 35
cola_digitos[6]
cola_digitos[7] 7
cola_digitos[8]
cola_digitos[9]
62
Ejemplo Radix sort
Conjunto a ordenar: { 33, 60, 5, 15, 25, 12, 45, 70, 35, 7}
frente cola
cola_digitos[0] 05 07
cola_digitos[1] 12
cola_digitos[2] 25
cola_digitos[3] 33 35
cola_digitos[4]
cola_digitos[5] 45
cola_digitos[6] 60
cola_digitos[7] 70
cola_digitos[8]
cola_digitos[9]
63
Radix sort directo
Se examinan los bits de derecha a izquierda

for k=0 to b-1


ordenar el array de forma estable
tomando solo el bit k

64
Radix sort en enteros
La ordenación resultante es estable:

65
Análisis de Tiempo de Ejecución
• Los algoritmos de burbuja, inserción, selección corren
en O(n2).
• El algoritmo quicksort, montones corren en O(nlogn)
• El algoritmo radix sort es O(n)

66
QUE ES UNA BÚSQUEDA ?

La búsqueda es una operación que tiene por objeto la localización


de un elemento dentro de la estructura de datos.

A menudo un programador estará trabajando con grandes


cantidades de datos almacenados en arreglos y pudiera resultar
necesario determinar si un arreglo contiene un valor que coincide
con algún valor clave o buscado.

Siendo el array de una dimensión o lista una estructura de acceso


directo y a su vez de acceso secuencial, encontramos dos
técnicas que utilizan estos dos métodos de acceso, para
encontrar elementos dentro de un array: búsqueda lineal y
búsqueda binaria.
QUE ES UNA BÚSQUEDA SECUENCIAL ?

La búsqueda secuencial es la técnica más simple para buscar un


elemento en un arreglo.
Consiste en recorrer el arreglo elemento a elemento e ir
comparando con el valor buscado (clave). Se empieza con la
primera casilla del arreglo y se observa una casilla tras otra hasta
que se encuentra el elemento buscado o se han visto todas las
casillas. El resultado de la búsqueda es un solo valor, y será la
posición del elemento buscado o cero. Dado que el arreglo no
está en ningún orden en particular, existe la misma probabilidad
de que el valor se encuentra ya sea en el primer elemento, como
en el último.
Pseudocódigo Búsqueda Secuencial:

1.- Llenar la lista o vector con datos


2.- Mostrar los elementos
3.- Pedir el valor a buscar
4.- Iniciar el ciclo que recorre la matriz
Si el valor de la matriz = a buscar
- muestra el valor y su posición
- salir del ciclo
Fin_ciclo
5.- Si no hay elementos y no encontró el valor buscado
Mandar el mensaje

Busca un valor en una matriz de 50 números aleatorios


QUE ES UNA BÚSQUEDA BINARIA ?

La búsqueda binaria es el método más eficiente para


encontrar elementos en un arreglo ordenado.
El proceso comienza comparando el elemento central
del arreglo con el valor buscado. Si ambos coinciden
finaliza la búsqueda. Si no ocurre así, el elemento
buscado será mayor o menor en sentido estricto que
el central del arreglo. Si el elemento buscado es
mayor se procede a hacer búsqueda binaria en el
subarray superior, si el elemento buscado es menor
que el contenido de la casilla central, se debe cambiar
el segmento a considerar al segmento que está a la
izquierda de tal sitio central.
Pseudocódigo BusquedaBinaria
(con cualquier metodo de ordenamiento):

1.- Inicio

2.- Declarar las siguientes funciones (prototipos)


a)ingresar.- obtener el numero que se desea busca
b)Ordenar.- ordena por cualquier método de ordenacion
c)Mostrar- muestra en pantalla el contenido del vector o lista
d)Buscar.- ejecuta el algoritmo de búsqueda binaria
e)Mensaje.- presenta el mensaje inicial

EJEMPLO
3.- Declarar variables y matriz de 100 elementos

4.-Mostrar mensaje de bienvenida


5.-Inicializar el generador de números aleatoreos
6.-Mostrar la matriz generada
7.-Ordenar la matriz por cualquier metodo de ordenacion
8.-Ingresar el numero a buscar en la matríz
9.-Buscar el número en la matriz
Si lo encuentra mostrar posición y valor (recursivo)
Si no lo encuentra mostrar mensaje.
10.- Termina
BÚSQUEDA MEDIANTE TRANSFORMACIÓN
DE LLAVES (Hashing)

En este método se requiere que los elementos estén ordenados.


(arreglos, archivos o Bases de Datos)

El método consiste en asignar el índice a cada elemento


mediante una transformación del elemento, esto se hace
mediante una función de conversión (hash)

La principal forma de transformar el elemento es asignarlo


directamente, es decir al 0 le corresponde el índice 0, al 1 el 1, y
así sucesivamente pero cuando los elementos son muy grandes
se desperdicia mucho espacio ya que necesitamos arreglo
grandes para almacenarlos y estos quedan con muchos espacios
libres, para utilizar mejor el espacio se utilizan funciones mas
complejas.
BÚSQUEDA MEDIANTE TRANSFORMACIÓN
DE LLAVES (Función Hash)

La función de hash ideal debería ser biyectiva, esto es,


que a cada elemento le corresponda un índice, y que a
cada índice le corresponda un elemento.

Esta función hash debe ser simple de calcular y debe


asignar direcciones de la manera más uniformemente
posible, es decir debe generar posiciones diferentes
dadas dos claves diferentes.

La función de hash depende de cada problema y de


cada finalidad, y se pueden utilizar con números o
cadenas, pero las más utilizadas son:
BÚSQUEDA MEDIANTE TRANSFORMACIÓN
DE LLAVES (Función Hash)

Restas sucesivas: Esta función se emplea con claves numéricas entre las
que existen huecos de tamaño conocido, obteniéndose direcciones
consecutivas.
Por ejemplo, si el número de expediente de un alumno universitario está
formado por el año de entrada en la universidad, seguido de un número
identificativo de tres cifras, y suponiendo que entran un máximo de 400
alumnos al año, se le asignarían las claves:
1998-000 --> 0 = 1998000-1998000
1998-001 --> 1 = 1998001-1998000
1998-002 --> 2 = 1998002-1998000
...
1998-399 --> 399 = 1998399-1998000
1999-000 --> 400 = 1999000-1998000+400
...
yyyy-nnn --> N = yyyynnn-1998000+(400*(yyyy-1998))
BÚSQUEDA MEDIANTE TRANSFORMACIÓN
DE LLAVES (Función Hash)

Aritmética modular: El índice de un número es resto de la división de ese


número entre un número N prefijado, preferentemente primo. Los números
se guardarán en las direcciones de memoria de 0 a N-1.

Este método tiene el problema de que cuando hay N+1 elementos, al menos
un índice es señalado por dos elementos (teorema del palomar). A este
fenómeno se le llama colisión, y es tratado más adelante. Si el número N es
el 13, los números siguientes quedan transformados en:
13000000 --> 0
12345678 --> 7
13602499 --> 1
71140205 --> 6
73062138 --> 6
BÚSQUEDA MEDIANTE TRANSFORMACIÓN
DE LLAVES (Función Hash)

Truncamiento: consiste en ignorar parte del número y utilizar los elementos restantes
como índice. También se produce colisión. Por ejemplo, si un número de 8 cifras se
debe ordenar en un array de 1000 elementos, se pueden coger la primer, la tercer y la
última cifras para formar un nuevo número:
13000000 --> 100
12345678 --> 138
13602499 --> 169
71140205 --> 715
73162135 --> 715

Plegamiento: consiste en dividir el número en diferentes partes, y operar con ellas


(normalmente con suma o multiplicación). También se produce colisión. Por ejemplo, si
dividimos los número de 8 cifras en 3, 3 y 2 cifras y se suman, dará otro número de
tres cifras (y si no, se cogen las tres últimas cifras):
13000000 --> 130=130+000+00
12345678 --> 657=123+456+78
71140205 --> 118 --> 1118=711+402+05
13602499 --> 259=136+024+99
25000009 --> 259=250+000+09
BÚSQUEDA MEDIANTE TRANSFORMACIÓN
DE LLAVES (Función Hash)
Mitad del cuadrado: consiste en elevar al cuadrado la clave y coger las
cifras centrales. Este método también presenta problemas de colisión:
123*123=15129 --> 51
136*136=18496 --> 84
730*730=532900 --> 29
301*301=90601 --> 06
625*625=390625 --> 06

Tratamiento de colisiones: Pero ahora se nos presenta el problema de qué


hacer con las colisiones, qué pasa cuando a dos elementos diferentes les
corresponde el mismo índice. Pues bien, hay tres posibles soluciones:

Cuando el índice correspondiente a un elemento ya está ocupada, se le


asigna el primer índice libre a partir de esa posición. Este método es poco
eficaz, porque al nuevo elemento se le asigna un índice que podrá estar
ocupado por un elemento posterior a él, y la búsqueda se ralentiza, ya que
no se sabe la posición exacta del elemento.
BÚSQUEDA MEDIANTE TRANSFORMACIÓN
DE LLAVES (Resolución de colisiones)

También se pueden reservar unos cuantos lugares al final del array para
alojar a las colisiones. Este método también tiene un problema: ¿Cuánto
espacio se debe reservar? Además, sigue la lentitud de búsqueda si el
elemento a buscar es una colisión.

Lo más efectivo es, en vez de crear un array de número, crear un array de


punteros, donde cada puntero señala el principio de una lista enlazada. Así,
cada elemento que llega a un determinado índice se pone en el último lugar
de la lista de ese índice. El tiempo de búsqueda se reduce
considerablemente, y no hace falta poner restricciones al tamaño del array,
ya que se pueden añadir nodos dinámicamente a la lista (ver listas).

También podría gustarte