ARCHIVOS DE ACCESO DIRECTO POR TRANSFORMACIÓN DE CLAVES.

Se asigna mediante una función HASH una posición a unas claves determinadas.

{por ejemplo, una función HASH sería dividir el número de clave entrew el número de elementos totales, y tomar el resto como resultado}

El problema con que nos vamos a encontrar son las Colisiones (elementos con claves distintas producen el mismo resultado en la función HASH).

Los elementos que colisionan se pueden llevar a :

     ·       Otro fichero (Fichero de Colisiones).
·       Al mismo fichero a partir de la íltima posición.

Si llegamos a una posición y la clave no es igual, se va a buscar a la zona de colisiones (secuencialmente).

{por ejemplo, si tengo 100 elementos, el número primo más próximo a 100 dará menos colisiones, y ese será el número de zona (de colisiones)) }

Type

            Reg=RECORD
                        clave :integer ; {suele ser string à transformarlo a número}
                        c1 : ------- ;
                        c2 : ------- ;
                        ocupado : boolean ; { también podemos usar un Char}
                        end ;
           

            Archivo=file of Reg ;
Var
            r :Reg ;
            f :Arch;
            i :integer ;

{--------------HASH------------------------------------------------------------------------------------}

Function Hash (clave :string) :integer ; {por ejemplo si la clave fuese ‘1234R’}

Var
            suma :integer ;
            i :byte ;
Begin
            suma :=0 ;
            For i :=1 to Length(clave) do          
                        suma :=suma+Ord(clave[i]) ;
            Hash :=suma MOD 100 ;
End ;

BEGIN
            Assign(f,’nombre.dat’) ;
            Rewrite(f) ; {creación}
            r.ocupado :=’’ ;
            For i :=0 to 99 do
            begin
                        Seek(f,i) ;
                        Write(f,r) ;
            end ;
END.

{--------------------------------------------------------------------------------------------------------------------------}

Program Altas ;

Type... 

Variable
            r :Reg ;
            f :Archivo ;
            Clave :integer ;
            encontrado :boolean ;
            p :integer ;
Begin
            Reset(f) ;
            WriteLn(‘Deme clave’) ;
            ReadLn(clave) ;
            While Clave<>0 do
            begin
                        p :=Hash(clave) ;
                        Seek(f,p) ;
                        Read(f,r) ;
                        If r.ocupado=’’ then
                                   encontrado :=true ; {el sitio}
                        Else
                        begin
                                   p :=99 ;
                                   encontrado :=false ;
                                   While (p<124) AND NOT encontrado do
                                   begin
                                               p :=p+1 ;
                                               Seek(f,p) ;
                                               Read(f,r) ;
                                               If r.ocupado=’’ then
                                                           encontrado :=true ;
                                   end ;
                        end ;
                        If encontrado then
                        begin
                                   Seek(f,p) ;
                                   Write(‘Deme campos) ;
                                   ReadLn(c1,c2,.... ) ;
                                   r.ocupado :=’*’ ;
                                   r.Clave :=Clave ;
                                   Write(f,r) ;
                        end ;
                        Write(‘Deme tora clave o 0 para fin ‘) ;
            end ;
            Close(f) ;
End.

{--------------------------------------------------------------------------------------------------------------------------}

f :text ; {obligatorio}
ReadLn(f,r,...) ;
While NOT EOF(f) do
begin
            Write(...) ;
            Read(...) ;
end ; {último no se escribe}
WriteLn(....) ;
<<<Arreglado>>>{aquí no hay que escribir cuando sale}
fin :=false ;
If NOT EOF(f) then
            ReadLn(f,....) ;
Else
            fin :=true ;
While NOT fin do
begin
            Write(f,r,...) ;
            If NOT EOF(f) then
                        ReadLn(f,r,...) ;
            Else
                        fin :=true ;
end ;

{--------------------------------------------------------------------------------------------------------------------------}

Program Ordenacion_Mezcla_Natural ;

Type
            Reg=RECORD
                        cod :byte ;
                        cantidad :integer ;
                        descuento :real ;
                        end ;
            Archivo =text ;
Variable
            f1,f2,f :Archivo ;
            r1,r2,r :Reg ;
            ant1,ant2,ant :byte ; {cod}
            ordenado,crece :boolean ;
            fin1,fin2,fin :boolean ;
            numsec :integer ;
Begin
            Assign(f,’inicial.dat’) ;
            Assign(f1,’auxi1.dat’) ;
            Assign(f2,’auxi2.dat’) ;
            ordenado :=false ;
            While NOT ordenado do
            begin
                        Reset(f) ;
                        Rewrite(f1) ;
                        Rewrite(f2) ;
                        fin :=false ;
                        If NOT EOF(f) then
                                   ReadLn(f,r.cod,r.cantidad,r.descuento) ;
                        Else
                                   fin :=true ;
                        While NOT fin do
                        begin
                        &nb