hash算法学习

hash算法

hash算法其实就是hash函数，也称散列函数，它讲任意长度的输入变换成固定长度的输出，该输出称为散列值(键值)。

这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意内容的输入转换成相同长度输出的加密方式。

hash函数建立键值与真实值之间的对应关系,(每一个真实值只能有一个键值,但是一个键值可以对应多个真实值),这样可以快速在数组等数据结构中存取数据。

常用的hash算法见下一篇博客。

hashtable

Hashtable 对象由包含集合元素的存储桶组成。存储桶是 Hashtable 中各元素的虚拟子组，与大多数集合中进行的搜索和检索相比，存储桶可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联，该哈希代码是使用哈希函数生 成的并基于该元素的键。

哈希函数是基于键返回数值哈希代码的算法。键是正被存储的对象的某一属性的值。哈希函数必须始终为相同的键返回相同的哈希代码。一个哈希函数能够为两个不同的键生成相同的哈希代码，但从哈希表检索元素时，为每一唯一键生成唯一哈希代码的哈希函数将令性能更佳。

以下内容来自http://www.blogjava.net/fisher/archive/2006/12/13/87398.html

Hashtable类   
  　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。   
  　　添加数据使用put(key,   value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。

Hashtable通过initial   capacity和load   factor两个参数调整性能。通常缺省的load   factor   0.75较好地实现了时间和空间的均衡。增大load   factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。   
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：   
  　　　　Hashtable   numbers   =   new   Hashtable();   
  　　　　numbers.put(“one”,   new   Integer(1));   
  　　　　numbers.put(“two”,   new   Integer(2));   
  　　　　numbers.put(“three”,   new   Integer(3));   
  　　要取出一个数，比如2，用相应的key：   
  　　　　Integer   n   =   (Integer)numbers.get(“two”);   
  　　　　System.out.println(“two   =   ”   +   n);   
  　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。   
  　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。   
  　　Hashtable是同步的。   

HashMap类   
  　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null   value和null   key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load   factor过低。   

WeakHashMap类  
  　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。 

HashSet

请参考对Set的描述   
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。   
Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。请注意：必须小心操作可变对象（Mutable   Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

两个通用Set实现是HashSet   和TreeSet。要决定用哪一个，那是非常简单明了的。 HashSet 要快得多(对大多数操作是常数时间之于对数时间（constant   time   vs.   log   time）),   但不提供排序保证。如果你需要使用   SortedSet   中的操作，或者按顺序迭代对你来说是重要的，那么请使用   TreeSet。   否则，使用   HashSet。   在大多数时间都不使用   HashSet   ，对你来说是个公平的赌博。     
    关于   HashSet，有一件事应该牢记，即就条目数和容量之和来讲，迭代是线性的。因此，如果迭代性能很重要，那就应该慎重选择一个适当的初始容量。容量选得太大，既浪费空间，也浪费时间。   默认的初试容量是101,   一般来讲，它比你所需要的要多。可以使用   int   构造函数来指定初始容量。要分配 HashSet 的初始容量为17:     
 Set   s=   new   HashSet(17);     
  　　HashSets   另有一个称作   装载因数（load   factor）   的"调整参数（tuning   parameter）"   。如果你非常在乎你的   HashSet   的空间的使用，请阅读   HashSet   文本以获取详细信息。否则，就使用默认值吧。如果你接受默认装载因数，但你确实又想指定初始容量，那么，选一个大约是你期望你的   Set   将增长到的容量的两倍的数。如果你的猜测不着边，它也可以增长，或只是浪费一点空间。但都没有大问题。如果你知道有关正确尺寸的一个最佳值，用它吧；如果不知道，那就使用一个旧的值，或使用一个偶数值。它真的不是非常重要。这些事情只能使   HashSet   稍稍变好一点点。     
    
  　　TreeSet 没有调整参数。除 clone 之外，HashSet   和   TreeSet   都仅有那些由它们各自的接口所要求的操作   (Set   和   TreeSet)，而没有任何别的操作。     
  

hashtable的实现

1、分离连接法（separate chaining）

#include<vector>
#include<list>
using namespace std;

template <typename HashedObj>
class HashTable
{
  public:
    explicit HashTable( int size = 101 );

    void makeEmpty( )
    {
        for( int i = 0; i < theLists.size( ); i++ )
            theLists[ i ].clear( );
    }

    bool contains( const HashedObj & x ) const
    {
        const list<HashedObj> & whichList = theLists[ myhash( x ) ];
        return find( whichList.begin( ), whichList.end( ), x ) != whichList.end( );
    }

    bool remove( const HashedObj & x )
    {
        list<HashedObj> & whichList = theLists[ myhash( x ) ];
        list<HashedObj>::iterator itr = find( whichList.begin( ), whichList.end( ), x );
        if( itr == whichList.end( ) )
            return false;
        whichList.erase( itr );
        --currentSize;
        return true;
    }

    bool insert( const HashedObj & x )
    {
        list<HashedObj> & whichList = theLists[ myhash( x ) ];
        if( find( whichList.begin( ), whichList.end( ), x ) != whichList.end( ) )
            return false;
        whichList.push_back( x );
        if( ++currentSize > theLists.size( ) )
            rehash( );
        return true;
    }

  private:
    vector<list<HashedObj> > theLists;   // The array of Lists
    int  currentSize;

    void rehash( )
    {
        vector<list<HashedObj> > oldLists = theLists;

        // Create new double-sized, empty table
        theLists.resize( nextPrime( 2 * theLists.size( ) ) );  //使用2*theLists.size( )以后最接近它的素数
        for( int j = 0; j < theLists.size( ); j++ )
            theLists[ j ].clear( );
        // Copy table over
        currentSize = 0;
        for( int i = 0; i < oldLists.size( ); i++ )
        {
            list<HashedObj>::iterator itr = oldLists[ i ].begin( );
            while( itr != oldLists[ i ].end( ) )
                insert( *itr++ );
        }
    }
    int myhash( const HashedObj & x ) const;
    {
        int hashVal = hash( x );
        hashVal %= theLists.size( );
        if( hashVal < 0 )
            hashVal += theLists.size( );
        return hashVal;
    }
};

// A hash function for sting object
int hash( const string & key, int tableSize)
{
    int hashVal = 0;
    for( int i = 0; i < key.length( ); i++ )
        hashVal = 37 * hashVal + key[ i ];
    hashVal %= tableSize;
    if( hashVal < 0)
        hashVal += tableSize;
    return hashVal;
}

2、使用探测法（probing hash tables）

template <typename HashedObj>
class HashTable
{
  public:
    explicit HashTable( int size = 101 ) : array( size ) )
    { makeEmpty( ); }

    void makeEmpty( )
    {
        currentSize = 0;
        for( int i = 0; i < array.size( ); i++ )
            array[ i ].info = EMPTY;
    }

    bool contains( const HashedObj & x ) const
    { return isActive( findPos( x ) ); }

    bool insert( const HashedObj & x )
    {
        // Insert x as active
        int currentPos = findPos( x );
        if( isActive( currentPos ) )
            return false;
        array[ currentPos ] = HashEntry( x, ACTIVE );
        if( ++currentSize > array.size( ) / 2 )
            rehash( );
        return true;
    }

    bool remove( const HashedObj & x )
    {
        int currentPos = findPos( x );
        if( !isActive( currentPos ) )
            return false;
        array[ currentPos ].info = DELETED;
        return true;
    }

    enum EntryType { ACTIVE, EMPTY, DELETED };

  private:
    struct HashEntry
    {
         HashedObj element;
         EntryType info;
         HashEntry( const HashedObj & e = HashedObj( ), EntryType i = EMPTY )
           : element( e ), info( i ) { }
    };

    vector<HashEntry> array;
    int currentSize;

    int findPos( const HashedObj & x ) const
    {
        int offset = 1;
        int currentPos = myhash( x );
        while( array[ currentPos ].info != EMPTY &&
                array[ currentPos ].element != x )
        {
            currentPos += offset;  // Compute ith probe
            offset += 2;
            if( currentPos >= array.size( ) )
                currentPos -= array.size( );
        }
        return currentPos;
    }

    bool isActive( int currentPos ) const
    { return array[ currentPos ].info == ACTIVE; }

    void rehash( )
    {
        vector<HashEntry> oldArray = array;
        // Create new double-sized, empty table
        array.resize( nextPrime( 2 * oldArray.size( ) ) );
        for( int j = 0; j < array.size( ); j++ )
            array[ j ].info = EMPTY;
        // Copy table over
        currentSize = 0;
        for( int i = 0; i < oldArray.size( ); i++ )
            if( oldArray[ i ].info == ACTIVE )
                insert( oldArray[ i ].element );
    }

    int myhash( const HashedObj & x ) const;
};