C++数据结构--.哈希表线性探测开放寻址法与独立表链地址法

1.哈希函数是个定位函数，它用键作为参数，返回表中的索引值
 


2.线性探测开放寻址法
  *调用哈希函数处理键得到哈希值，用值除以表的长度后取余数，从而确定表中的一个位置
  *如果该位置非空，则探测下一个位置，到达表最后一项时，折回表头。
  *如果回到原来哈希位置上时还未找到空闲位置，说明表已经填满了。


   例如：hash(key)=key%11
 
   

  

  

3.独立表链地址法
  *把哈希表定义成容器（如向量和链表）的索引序列，每个容器（bucket)用来保存映射到同一位置上的数据集合
 
   
   使用独立表链地址法存储上面线性探测开放寻址法存储的数据
 
   


   实现代码：
 #ifndef hashTable_H
#define hashTable_H
#include
#include

using namespace std;

template
class hashTable
{
friend class hashIterator;
private:
vector> table; 
hashFun fun;  //哈希函数对象
size_t rows;    
public:
#include"hashIterator.h"  //详见C++数据结构--.哈希表独立表链地址法迭代器的设计
hashTable(size_t r,hashFun hf=hashFun()):table(r),rows(r),fun(hf){}
   
 //查找val所在的迭代器位置 
hashIterator find(const T &val)
{
int r=fun(val)%rows;//用哈希函数定位 
if(table[r].empty()) //val不存在哈希表中，返回end() 
{

return hashIterator(this,-1,table[r].end());
}
else
{
  typenamelist::iterator it=table[r].begin();
  for(;it!=table[r].end();it++)//遍历哈希函数定位的行 
  {
  if(*it==val)
    return hashIterator(this,r,it);
  }
 return hashIterator(this,-1,table[r].end());//不存在val,返回end() 
}
}

//插入val,返回 hashIterator-bool键值对 
pair insert(const T &val)
{
hashIterator hit=find(val);//查找val所在的迭代器位置 
size_t r=fun(val)%rows;//用哈希函数定位 
bool success=false; //查找是否成功标志 
if(hit.row==-1) //当val不存在哈希表时，插入val 
{
typename list::iterator it=table[r].end();
it=table[r].insert(it,val);
success=true;
return make_pair(hashIterator(this,r,it),success);
}

return make_pair(hit,success);//当val存在哈希表时，返回val所在迭代器位置，但不插入 

}


//删除val 
void erase(const T &val)
{
hashIterator hit=find(val);
size_t r=fun(val)%rows;
if(hit.row==-1) //val不存在哈希表示，删除非法 
{
cerr<<"value "<
return;
}

table[r].erase(hit.it);
 
}

//删除迭代器指定的位置 
void erase(hashIterator pos)
            {
        if(pos==end())//删除end()，非法 
         {
         cerr<<"can't erase end()"<
         return;
         } 
           
           T val=*pos;
           erase(val);
       
        }

//返回第一个元素所在的迭代器位置
hashIterator begin()
{
for(int i=0;i
       {
        if(!table[i].empty())
  return hashIterator(this,i,table[i].begin());
       }

 return hashIterator(this,-1,table[0].end()); //哈希表为空时返回end() 
}

//返回end()迭代器 
hashIterator end()
{
return hashIterator(this,-1,table[0].end());
}

 

};


#endif


测试代码：
#include
#include"hashTable.h"
using namespace std;

class hashFun  //哈希函数对象类

{
public:
size_t operator()(size_t val)
{
return val;
}

};


int main(int argc, char** argv)
 {


hashTable ht(11);
ht.insert(54);
ht.insert(77);
ht.insert(94);
ht.insert(89);
ht.insert(14);
ht.insert(45);
ht.insert(35);
ht.insert(76);
cout<<"in ht : ";
for(int x:ht)
{
cout<} 

auto p=ht.insert(94);
cout<if(!p.second)
 cout<<"duplicate val "<<*p.first<<" can't be inserted"<ht.erase(100); //删除不存在的元素
auto p1=ht.end();    
ht.erase(p1); //删除end()迭代器
p1++;        //end()迭代器自增 
auto p2=ht.find(94);//查找94 
ht.erase(p2); //删除迭代器指定的元素 
ht.erase(89);  //删除89 
cout<<"after erase 94 ,89: "<

for(int x:ht)
{
cout<
} 

   return 0;
}



运行结果：