hash算法收集

C++ Code: (收集)

//  RS Hash Function
unsigned  int  RSHash( char *  str)
{
    unsigned  int  b  =   378551 ;
    unsigned  int  a  =   63689 ;
    unsigned  int  hash  =   0 ;

     while  ( * str)
    {
        hash  =  hash  *  a  +  ( * str ++ );
        a  *=  b;
    }

     return  (hash  &   0x7FFFFFFF );
} 
 
//  JS Hash Function
unsigned  int  JSHash( char *  str)
{
    unsigned  int  hash  =   1315423911 ;

     while  ( * str)
    {
        hash  ^=  ((hash  <<   5 )  +  ( * str ++ )  +  (hash  >>   2 ));
    }

     return  (hash  &   0x7FFFFFFF );
}
 
//  P.J.Weinberger Hash Function
unsigned  int  PJWHash( char *  str)
{
    unsigned  int  BitsInUnignedInt  =  (unsigned  int )(sizeof(unsigned  int )  *   8 );
    unsigned  int  ThreeQuarters     =  (unsigned  int )((BitsInUnignedInt  *   3 )  /   4 );
    unsigned  int  OneEighth         =  (unsigned  int )(BitsInUnignedInt  /   8 );

    unsigned  int  HighBits          =  (unsigned  int )( 0xFFFFFFFF )  <<  (BitsInUnignedInt  -  OneEighth);
    unsigned  int  hash              =   0 ;
    unsigned  int  test              =   0 ;

     while  ( * str)
    {
        hash  =  (hash  <<  OneEighth)  +  ( * str ++ );
         if  ((test  =  hash  &  HighBits)  !=   0 )
        {
            hash  =  ((hash  ^  (test  >>  ThreeQuarters))  &  ( ~ HighBits));
        }
    }

     return  (hash  &   0x7FFFFFFF );
} 
 
//  ELF Hash Function
unsigned  int  ELFHash( char *  str)
{
    unsigned  int  hash  =   0 ;
    unsigned  int  x     =   0 ;

     while  ( * str)
    {
        hash  =  (hash  <<   4 )  +  ( * str ++ );
         if  ((x  =  hash  &   0xF0000000L )  !=   0 )
        {
            hash  ^=  (x  >>   24 );
            hash  &=   ~ x;
        }
    }

     return  (hash  &   0x7FFFFFFF );
}

//  BKDR Hash Function
unsigned  int  BKDRHash( char *  str)
{
    unsigned  int  seed  =   131 ;   //   31 131 1313 13131 131313 etc..
    unsigned  int  hash  =   0 ;

     while  ( * str)
    {
        hash  =  hash  *  seed  +  ( * str ++ );
    }

     return  (hash  &   0x7FFFFFFF );
}

//  SDBM Hash Function
unsigned  int  SDBMHash( char *  str)
{
    unsigned  int  hash  =   0 ;

     while  ( * str)
    {
        hash  =  ( * str ++ )  +  (hash  <<   6 )  +  (hash  <<   16 )  -  hash;
    }

     return  (hash  &   0x7FFFFFFF );
}

//  DJB Hash Function
unsigned  int  DJBHash( char *  str)
{
    unsigned  int  hash  =   5381 ;

     while  ( * str)
    {
        hash  +=  (hash  <<   5 )  +  ( * str ++ );
    }

     return  (hash  &   0x7FFFFFFF );
}

//  AP Hash Function
unsigned  int  APHash( char *  str)
{
    unsigned  int  hash  =   0 ;
     int  i;

     for  (i  =   0 ;  * str; i ++ )
    {
         if  ((i  &   1 )  ==   0 )
        {
            hash  ^=  ((hash  <<   7 )  ^  ( * str ++ )  ^  (hash  >>   3 ));
        }
         else
        {
            hash  ^=  ( ~ ((hash  <<   11 )  ^  ( * str ++ )  ^  (hash  >>   5 )));
        }
    }

     return  (hash  &   0x7FFFFFFF );
}

Pascal Code: (我自己转的)

//  RS Hash  Function
function  RSHash(S:  string ): Cardinal;
var
  a, b: Cardinal;
  I:  Integer ;
begin
  Result : =   0 ;
  a : =   63689 ;
  b : =   378551 ;

   for  I : =   1   to  Length(S)  do
  begin
    Result : =  Result  *  a  +  Ord(S[I]);
    a : =  a  *  b;
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

//  JS Hash  Function
function  JSHash(S:  string ): Cardinal;
var
  I:  Integer ;
begin
  Result : =   1315423911 ;

   for  I : =   1   to  Length(S)  do
  begin
    Result : =  ((Result shl  5 )  +  Ord(S[I])  +  (Result shr  2 ))  xor  Result;
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

//  P.J.Weinberger Hash  Function
function  PJWHash(S:  string ): Cardinal;
var
  OneEighth,
  ThreeQuarters,
  BitsInUnignedInt,
  HighBits,
  test: Cardinal;
  I:  Integer ;
begin
  Result : =   0 ;
  test   : =   0 ;

  BitsInUnignedInt : =  SizeOf(Cardinal)  *   8 ;
  ThreeQuarters    : =  BitsInUnignedInt  *   3  div  4 ;
  OneEighth        : =  BitsInUnignedInt div  8 ;
  HighBits         : =  $FFFFFFFF shl (BitsInUnignedInt  -  OneEighth);

   for  I : =   1   to  Length(S)  do
  begin
    Result : =  (Result shl OneEighth)  +  Ord(S[I]);
    test   : =  Result  and  HighBits;
     if  test  <>   0   then  Result : =  ((Result  xor  (test shr ThreeQuarters))  and   not  HighBits);
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

//  ELF Hash  Function  
function  ELFHash(S:  string ): Cardinal;
var
  X: Cardinal;
  I:  Integer ;
begin
  Result : =   0 ;
  X : =   0 ;

   for  I : =   1   to  Length(S)  do
  begin
    Result : =  (Result shl  4 )  +  Ord(S[I]);
    X : =  Result  and  $F0000000;
     if  X  <>   0   then
    begin
      Result : =  Result  xor  (X shr  24 );
      Result : =  Result  and   not  X;
     end ;
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

//  BKDR Hash  Function
function  BKDRHash(S:  string ): Cardinal;
var
  seed: Cardinal;
  I:  Integer ;
begin
  Result : =   0 ;
  seed   : =   131 ;   //   31   131   1313   13131   131313  etc..

   for  I : =   1   to  Length(S)  do
  begin
    Result : =  Result  *  seed  +  Ord(S[I]);
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

//  SDBM Hash  Function
function  SDBMHash(S:  string ): Cardinal;
var
  I:  Integer ;
begin
  Result : =   0 ;

   for  I : =   1   to  Length(S)  do
  begin
    Result : =  Ord(S[I])  +  (Result shl  6 )  +  (Result shl  16 )  -  Result;
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

//  DJB Hash  Function
function  DJBHash(S:  string ): Cardinal;
var
  I:  Integer ;
begin
  Result : =   5381 ;

   for  I : =   1   to  Length(S)  do
  begin
    Result : =  Result  +  (Result shl  5 )  +  Ord(S[I]);
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

//  AP Hash  Function  
function  APHash(S:  string ): Cardinal;
var
  I:  Integer ;
begin
  Result : =   0 ;

   for  I : =   1   to  Length(S)   do
  begin
     if  (i  and   1 )  <>   0   then
      Result : =  Result  xor  ((Result shl  7 )  xor  Ord(S[I ])  xor  (Result shr  3 ))
     else
      Result : =  Result  xor  ( not  (Result shl  11 )   xor  Ord(S[I ])  xor  (Result shr  5 ));
   end ;

  Result : =  Result  and  $7FFFFFFF;
end ;

不支持Pascal代码高亮,郁闷...

转载于:https://www.cnblogs.com/sephil/archive/2006/08/11/Hash.html