散列

选择键值，冲突的时候采取不同的策略

散列函数：

简单的散列函数：

int hash(const string & key,int tableSize)
{
    int hashVal = 0;
    for(int i = 0; i < key.length();++i)
    {
        hashVal + = key[i];
    }
    return hashVal % tableSize;
}

比较好的散列函数：

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;
}

键的长度和性质 影响选择。

分离链接法

分离链接散列表的类构架

template <typename HashedObj>
class HashTable
{
public:
    explicit HashTable( int size = 101);
    bool contains (const HashedObj & x) const;
    void makeEmpty();
    void insert(const HashedObj & x);
    void remove(const HashedObj & x);
private:
    vector<list<HashedObj> > theLists;
    int currentSize;
    void rehash();
    int myhash( const HashedObj & x) const;
};
int hash(const string & key);
int hash(int key);

散列表myhash的成员函数：

int myhash(const HashedObj & x) const
{
    int hashVal = hash(x);
    hashVal %= theLists.size();
    if(hashVal < 0)
        hashVal += theLists.size();
    return hashVal;
}

使用name成员为键，提供的散列函数实例：

class Employee
{
public:
    const string & getName() const
    {
        return name;
    }
    bool operator==( const Employee & rhs ) const
    {
        return getName() == rhs.getName();
    }
    bool operator!=(const Employee & rhs) const
    {
        return !(*this == rhs);
    }
private:
    string name;
    double salary;
    int seniority;
};
int hash(const Employee & item)
{
    return hash(item.getName());
}

实现makeEmpty contains remove：

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) const
{
    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;
}

分离散列表的insert实例

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;
}

装填因子：散列表中的元素个数 与 散列表大小的 比值

执行一次查找所需的时间：计算散列函数值所需要的常数时间加上遍历表所用的时间

不使用链表的散列表：

当冲突发生时，直接寻找下一单元

<线性探测>

<平方探测>

使用探测策略的散列表的类接口

template <typename HashedObj>
class HashedObj
{
public:
    explicit HashTable(int size = 101);
    bool contains(const HashedObj & x) const;
    void makeEmpty();
    bool insert(const HashedObj & x);
    bool remove(const HashedObj & x);
    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;
    bool isActive(int currentPos) const;
    int findPos(const HashedObj & x) const;
    void rehash();
    int myhash(const HashedObj & x) const;
};

初始化平方探测散列表

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

使用平方探测进行散列的contains findPos isActive

bool contains(const HashedObj & x) const
{
    return isActive(findPos(x));
}
int findPos(const HashedObj & x) const
{
    int offset = 1;
    int currentPos = myhash(x);

    while(array[currentPos].info != EMPTY && array[currentPos].element != x)
    {
        currentPos += offset;
        offset += 2;
        if(currentPos >= array.size())
            currentPos -= array.size();
    }
    return currentPos;
}
bool isActive(int currentPos) const
{
    return array[currentPos].info == ACTIVE;
}

使用平方探测的insert remove

bool insert( const HashedObj & x)
{
    int currentPos = findPos(x);
    if(isActive( currentPos ))
        return false;
    array[currentPos] = HashEntry(x,ACTIVE);
    if(++currnetSize>array.size()/2)
        rehash();
}
bool remove(const HashedObj & x)
{
    int currentPos = findPos(x);
    if(!isActive(currentPos))
        return false;
    array[currentPos].info = DELETED;
    return true;
}

<双散列>

对分离散列表的再散列

void rehash()
{
    vector<HashEntry> oldArray = array;
    array.size(nextPrime(2*oldArray.size()));
    for(int j = 0; j < array.size(); j++)
    {
        array[j].info = EMPTY;
    }
    currentSize = 0;
    for(int i = 0; i < array.size(); i++)
    {
        if(oldArray[i].info == ACTIVE)
            insert(oldArray[i].element);
    }
}

对探测散列表的再散列

void rehash()
{
    vector<list<HashedObj> > oldLists = theLists;
    theLists.resize( nextPrime( 2*theLists.size() ) );
    for(int j = 0; j < theLists.size(); j++)
    {
        theLists[j].clear();
    }
    currentSize = 0;
    for(int i = 0; i < oldLists.size(); i++)
    {
        list<HashedObj>::iterator itr = oldLists[i].begin();
        while( itr ！= oldLists[i].end( ) )
            insert(*itr++);
    }
}