TECNOLGICO NACIONAL DE MXICO

TECNOLGICO NACIONAL DE TIJUANA

SUBDIRECCIN ACADMICA
DEPARTAMENTO DE SISTEMAS Y COMPUTACIN
SEMESTRE AGOSTO-DICIEMBRE 2016
ING. SISTEMAS COMPUTACIONALES
MATERIA: ESTRUCTURA DE DATOS
DOCENTE:SAUCEDO LARES FERNANDO ELIHONAI
UNIDAD 6
MTODOS DE ORDENAMIENTO
(MTODO HASH EN CONSOLA)
CAMPOS LPEZ ALEXIS
HERNNDEZ PIMENTEL MARIANO
MORA AGUILAR CRISTIAN IGNACIO
MORALES NUEZ DANIEL ISA
ZERMEO RODRGUEZ JOS

15211886
15211899
15211325
15211906
15211918

EQUIPO: CHICHARITOS

05 DE DICIEMBRE DEL 2016

ndice
Concepto y Caractersticas

3-5

Ejemplo

6-7

Algoritmo (Pseudocdigo)

7-8

Cdigo
Uso de memoria
Arreglos pequeos

9-13
14
14-15

Arreglos grandes

16-17

Lmite

18-19

Bibliografa

19

Conceptos y Caractersticas
Bsqueda Hash
El mtodo consiste en asignar el ndice a cada elemento con una transformacin del
elemento, esto se hace mediante una funcin de conversin llamada funcin hash.
Hay diferentes funciones para transformar el elemento y el nmero obtenido toma el
valor del ndice del elemento.
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
arreglos grandes para almacenarlos y estos quedan con muchos espacios libres,
para utilizar mejor el espacio se utilizan funciones ms complejas.
La funcin de hash ideal debera ser biyectiva, esto es, que a cada elemento le
corresponde un ndice, y que a cada ndice le corresponda un elemento, pero no
siempre es fcil encontrar esa funcin, e incluso a veces es intil, ya que puedes no
saber el nmero de elementos a almacenar.
Hay diversos mtodos de Hashing, entre los cuales destacan:
1.- Restas sucesivas. Esta funcin se emplea con claves numricas entre las que
existan huecos de tamao conocido, obtenindose direcciones consecutivas. Un
ejemplo seran los nmeros de control de una universidad, son consecutivos y est
definido el nmero de alumnos.
15210000 -15210000 -> 0
15210001 -15210000 -> 1
15210002 -15210000 -> 2

15210400 -15210000 -> 400

2.- Aritmtica modular. El ndice de un nmero es resto de la divisin de ese
nmero entre un nmero N prefijado, preferentemente primo. Los nmeros se
guardarn en las direcciones de memoria de 0 a N-1. Este mtodo tiene el problema
de que dos o ms elementos pueden producir el mismo residuo y un ndice puede
ser sealado por varios elementos. A este fenmeno se le llama colisin. Si el
nmero N es el 7, los nmeros siguientes quedan transformados en:
1679 -> 6
4567 -> 3
8471 -> 1
0435 -> 1
5033 -> 0

Mientras ms grande sea nmero de elementos es mejor escoger un nmero primo

mayor para seccionar el arreglo en ms partes. El nmero elegido da el nmero de
partes en que se secciona el arreglo, y cada seccin est compuesta por todos los
elementos que arrojen el mismo residuo, y mientras ms pequeas sean las
secciones la bsqueda se agilizar ms que es lo que nos interesa.
3.- Mitad del cuadrado. Consiste en elevar al cuadrado la clave y coger las cifras
centrales. Este mtodo tambin presenta problemas de colisin.
709^2=502681 -> 26
456^2=207936 -> 79
105^2=11025 -> 10
879^2=772641 -> 26
619^2=383161 -> 31
4.- Truncamiento. Consiste en ignorar parte del nmero y utilizar los elementos
restantes como ndice. Tambin se produce colisin. Por ejemplo, si un nmero de 7
cifras se debe ordenar en un arreglo de elementos, se pueden tomar el segundo, el
cuarto y el sexto para formar un nuevo nmero:
5700931 -> 703
3498610 -> 481
0056241 -> 064
9134720 -> 142
5174829 -> 142
5.- Plegamiento. Consiste en dividir el nmero en diferentes partes, y operar con
ellas (normalmente con suma o multiplicacin). Tambin se produce colisin. Por
ejemplo, si dividimos el nmero de 7 cifras en 2, 2 y 3 cifras y se suman, dar otro
nmero de tres cifras (y si no, se toman las tres ltimas cifras): 5700931 -> 57 + 00
+ 931 = 988
3498610 -> 34 + 98 + 610 = 742
0056241 -> 00 + 56 + 241 = 297
9134720 -> 91 + 34 + 720 = 845
5174929 -> 51 + 74 + 929 = 1054
Nota: Estas solo son sugerencias y que con cada problema se puede implementar
una nueva funcin hash que incluso tu puedes inventar o formular.
Ventajas:

Rpido y eficiente.

Acceso a los datos suele ser muy rpido.

Desventajas:

Arreglo ya ordenado.

Desaprovechamiento de la memoria.

Si hay 2 elementos iguales encuentra el primero.

Caractersticas de los hash

En definitiva las funciones hash se encargan de representar de forma compacta un
archivo o conjunto de datos que normalmente es de mayor tamao que el hash
independientemente del propsito de su uso.
Este sistema de criptografa usa algoritmos que aseguran que con la respuesta (o
hash) nunca se podr saber cules han sido los datos insertados, lo que indica que
es una funcin unidireccional. Sabiendo que se puede generar cualquier resumen a
partir de cualquier dato nos podemos preguntar si se podran repetir estos
resmenes (hash) y la respuesta es que tericamente s, podra haber colisiones, ya
que no es fcil tener una funcin hash perfecta (que consiga que no se repita la
respuesta), pero esto no supone un problema, ya que si se consiguiera (con un
buen algoritmo) que dos hash son iguales los contenidos seran totalmente distintos.
Tratamiento de colisiones
Hay diferentes maneras de solucionarlas pero lo ms efectivo es en vez de crear un
arreglo de nmero, crear un arreglo de punteros, donde cada puntero seala 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 bsqueda se
reduce considerablemente, y no hace falta poner restricciones al tamao del arreglo,
ya que se pueden aadir nodos dinmicamente a la lista.
PRUEBA LINEAL
Consiste en que una vez detectada la colisin se debe recorrer el arreglo
secuencialmente a partir del punto de colisin, buscando al elemento. El proceso de
bsqueda concluye cuando el elemento es hallado, o bien cuando se encuentra una
posicin vaca. Se trata al arreglo como a una estructura circular: el siguiente
elemento despus del ltimo es el primero. La funcin de rehashing es, por tanto, de
la forma: R(H(X)) = (H(X) + 1) % m (siendo m el tamao del arreglo) Ejemplo: Si la
posicin 397 ya estaba ocupada, el registro con clave 0596397 es colocado en la
posicin 398, la cual se encuentra disponible. Una vez que el registro ha sido
insertado en esta posicin, otro registro que genere la posicin 397 o la 398 es
insertado en la posicin siguiente disponible.

Ejemplo
1.- Restas sucesivas.
Valor Original

Valor Constante

Valor resultante

15210000

15210000

15210001

15210000

15210002

15210000

...

...

...

15210400

15210000

400

2.- Aritmtica modular.

Valor original

Valor modular tomando el primo 7

1679

4567

8471

0435

5033

3.- Mitad del cuadrado.

Valor original

Elevado al cuadrado

Valor resultante

709

502681

26

456

207936

79

105

11025

10

879

772641

26

619

383161

31

4.- Truncamiento.
Valor original

Valor resultante (segundo, cuarto y

sexto valor)

5700931

703

3498610

481

0056241

064

9134720

142

5174829

142

5.- Plegamiento.
Valor original

Primera
particin

Segunda
particin

Tercera
particin

Valor
resultante

5700931

57

00

931

988

3498610

34

98

610

742

0056241

00

56

241

297

9134720

91

34

720

845

5174929

51

74

929

1054

Algoritmo (Pseudocdigo)
1: Inicio
2: Vector1, Vector2 arreglos enteros
3: Introducir el tamao del arreglo Vector1 y se guarda en variable entero
tamao
4: Vector1 = nuevo entero[tamao]
5: Vector2 = nuevo entero[tamao]
Llenar Vector1 con nmeros aleatorios
6: para entero i = 0; i < tamao del arreglo Vector1; i incremento
Vector1[i] = nmero aleatorio del 1 al 1000000
7: Escribir Arreglo generado
Desplegar el contenido del arreglo Vector1
8: para entero i = 1; i <= tamao del arreglo Vector1; i incremento
escribir i + .- + Vector[i 1]

Aadir direcciones al arreglo

9: residuo1, residuo2, l enteros
10: para l = 0; l <= tamao del arreglo Vector1 1; l incremento
residuo1 = (Vector[l] % tamao del arreglo Vector1 1) + 1
mientras Vector2[residuo1] = 0
residuo2 = residuo1 + 1
si residuo2 > tamao del arreglo Vector1 1
residuo1 = 0
sino
residuo1 = residuo2
Vector2[residuo1] = Vector[l]
11: Escribir Direcciones asignadas
Bsqueda hash
12: residuo1, residuo2 enteros
Impresin del arreglo
13: para entero i = 1; i <= tamao del arreglo Vector2; i incremento
escribir lnea i + .- + Vector2[i 1]
Buscar elemento
14: Introducir el elemento que se desea buscar y se guarda en variable entero
elemento
15: residuo1 = (elemento % tamao del arreglo Vctor2 1) + 1
16: si Vector2[residuo1] == elemento
escribir lnea El elemento: {0}, est en la posicin: {1}, elemento,
residuo1 + 1
17: sino
residuo2 = residuo1 + 1
mientras (residuo2 <= tamao del arreglo Vector2 1 y
Vector2[residuo2] = elemento y Vector2[residuo2] = 0 y residuo2 = residuo1)
residuo2 = residuo2 + 1
si residuo2 > tamao del arreglo Vector2 1
residuo2 = 0
si Vector2[residuo2] == elemento
escribir lnea El elemento: {0}, est en la posicin: {1},
elemento, residuo2 + 1
sino
escribir lnea El elemento: {0}, no est en el arreglo.,
elemento,
18: Fin

Cdigo
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//Libreras extras para calcular el tiempo de ejecucin
using System.Diagnostics;
using System.Threading;
namespace Hash
{
class Hash
{
//Creacin del objeto de nmeros aleatorios
Random random = new Random();
//Creacin de los arreglos. "Vector1" es el arreglo sin asignar direcciones.
"Vector2" es el arreglo con direcciones asignadas
public int[] Vector1;
public int[] Vector2;
//Mtodo para llenar el Vector1 con numeros aleatorios (1 - 1000000)
public void GenerarArreglo(int _tamao)
{
//Asigna el tamao del arrglo capturado por el usuario
Vector1 = new int[_tamao];
Vector2 = new int[_tamao];
for (int i = 0; i < Vector1.Length; i++)
{
Vector1[i] = random.Next(1, 1000000);
}
Console.Write("\nArreglo generado.\nPresione <ENTER> para regresar
al men... ");
}
//Mtodo para desplegar el contenido del arreglo "Vector1" (generalmente
sin ordenar)
public void Desplegar()
{
for (int i = 1; i <= Vector1.Length; i++)
{
Console.WriteLine(i + ".- " + Vector1[i - 1]);

}
Console.Write("\nPresione <ENTER> para regresar al men...");
}
//Mtodo para aadir direciones al arreglo
public void Direccion()
{
//Creacin del objeto para contar el tiempo de ejecucin
Stopwatch stopWatch = new Stopwatch();
//Inicializa la cuenta de tiempo
stopWatch.Start();
int residuo1, residuo2, I;
for (I = 0; I <= Vector1.Length - 1; I++)
{
residuo1 = (Vector1[I] % Vector1.Length - 1) + 1;
while (Vector2[residuo1] != 0)
{
residuo2 = residuo1 + 1;
if (residuo2 > Vector1.Length - 1)
residuo1 = 0;
else
residuo1 = residuo2;
}
Vector2[residuo1] = Vector1[I];
}
//Termina la cuenta de tiempo
stopWatch.Stop();
Console.WriteLine("\nDirecciones Asignadas");
//Objeto que obtiene el valor de la cuenta de tipo TimeSpan
TimeSpan ts = stopWatch.Elapsed;
//Asigna los valores en formato: hora, minutos,segundos y
milisegundos a una variable string
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
Console.WriteLine("Tiempo de bsqueda: " + elapsedTime);
}
//Mtodo de bsqueda hash
public void hash()
{
int residuo1, residuo2;

10

//Impresin del arreglo

for (int i = 1; i <= Vector2.Length; i++)
{
Console.WriteLine(i + ".- " + Vector2[i - 1]);
}
//Bsqueda del elemento
Console.Write("\nIntroduzca el elemento que desea buscar: ");
int elemento = Int32.Parse(Console.ReadLine());
residuo1 = (elemento % Vector2.Length - 1) + 1;
if (Vector2[residuo1] == elemento)
{
Console.WriteLine("El elemento: {0}, est en la posicin: {1}",
elemento, (residuo1 + 1));
}
else
{
residuo2 = residuo1 + 1;
while ((residuo2 <= Vector2.Length - 1) && (Vector2[residuo2] !=
elemento) && (Vector2[residuo2] != 0) && (residuo2 != residuo1))
{
residuo2 = residuo2 + 1;
if (residuo2 > Vector2.Length - 1)
residuo2 = 0;
}
if (Vector2[residuo2] == elemento)
Console.WriteLine("El elemento: {0}, est en la posicin: {1}",
elemento, (residuo2 + 1));
else
Console.WriteLine("El elemento: {0}, no est en el arreglo.",
elemento);
}
}
}
class Program
{
static void Main(string[] args)
{
int opcion, tamao;
Hash H = new Hash();
do
{
Console.Clear();

11

Console.WriteLine("\tMENU");
Console.WriteLine("1.- Generar Arreglo Aleatorio.");
Console.WriteLine("2.- Desplegar Vector 1");
Console.WriteLine("3.- Asignar Direcciones.");
Console.WriteLine("4.- Desplegar Vector 2 y Buscar Elemento.");
Console.WriteLine("5.- Salir del programa.");
Console.Write("\nIngrese una opcin: ");
opcion = Int16.Parse(Console.ReadLine());
switch (opcion)
{
case 1:
Console.Write("\nIndica el tamao del arreglo: ");
tamao = Int32.Parse(Console.ReadLine());
Console.Clear();
H.GenerarArreglo(tamao);
Console.ReadKey();
break;
case 2:
Console.Clear();
H.Desplegar();
Console.ReadKey();
break;
case 3:
Console.Clear();
H.Direccion();
Console.ReadKey();
break;
case 4:
int opc = 0;
do
{
Console.Clear();
H.hash();
Console.WriteLine("\n1-. Buscar otro dato");
Console.WriteLine("2-. Regresar al men");
Console.Write("\nIntroduce una opcin: ");
opc = Int32.Parse(Console.ReadLine());
switch (opc)
{
case 1:
break;
case 2:

12

break;
default:
Console.WriteLine("Valor no vlido");
Console.ReadKey();
break;
}
} while (opc != 2);
break;
case 5:
Console.Write("\nPresione ENTER para salir...");
Console.ReadKey();
break;
default:
Console.Write("Opcin incorrecta");
Console.ReadKey();
break;
}
} while (opcion != 5);
}
}

13

Uso de memoria
Arreglos Pequeos
La memoria utilizada en un arreglo pequeo (10,000 Elementos) es de 5,016 kb al
trmino de la ejecucin de todas las opciones.

14

15

Arreglos Grandes
La memoria utilizada en un arreglo grande(1000,000 Elementos) es de 12,652 kb al
trmino de la ejecucin de todas las opciones.

16

17

Lmite

18

Bibliografa:
[1]http://www.programacionfacil.com/estructura_datos_csharp/busqu
eda_hash.html
[2]http://descarga-tareas.blogspot.mx/2010/11/estructura-de-datos-c-b
usqueda-hash.html
[3]https://prezi.com/0avokopqs-4r/funcion-hash/
[4]http://www.genbetadev.com/seguridad-informatica/que-son-y-para
-que-sirven-los-hash-funciones-de-resumen-y-firmas-digitales
[5]https://msdn.microsoft.com/es-mx/library/0xdxysd8(v=vs.90).aspx

19