哈希表原理与hash_map应用-优快云博客

本文介绍了哈希表的基本原理，包括直接定址和冲突解决方法，并详细讲解了hash_map的使用方法，包括自定义哈希函数和比较函数的过程。

原理：

　　使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素“分类”，然后将这个元素存储在相应“类”所对应的地方，称为桶。

　　但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突”，换句话说，就是把不同的元素分在了相同的“类”之中。总的来说，“直接定址”与“解决冲突”是哈希表的两大特点。

hash_map，首先分配一大片内存，形成许多桶。是利用hash函数，对key进行映射到不同区域（桶）进行保存。其插入过程是：

得到key
通过hash函数得到hash值
得到桶号(一般都为hash值对桶数求模)
存放key和value在桶内。

其取值过程是:

得到key
通过hash函数得到hash值
得到桶号(一般都为hash值对桶数求模)
比较桶的内部元素是否与key相等，若都不相等，则没有找到。
取出相等的记录的value。

　　hash_map中直接地址用hash函数生成，解决冲突，用比较函数解决。这里可以看出，如果每个桶内部只有一个元素，那么查找的时候只有一次比较。当许多桶内没有值时，许多查询就会更快了(指查不到的时候).

　　由此可见，要实现哈希表, 和用户相关的是：hash函数和比较函数。这两个参数刚好是我们在使用hash_map时需要指定的参数。

　　没有指定hash函数和比较函数的时候，你会有一个缺省的函数，看看hash_map的声明，下面是SGI STL的声明：

template <class _Key, class _Tp, class _HashFcn = hash<_Key>,
class _EqualKey = equal_to<_Key>,
class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class hash_map
{
        ...
}

等同于

hash_map<int, string> mymap;
//等同于:
hash_map<int, string, hash<int>, equal_to<int> > mymap;

　　原来是个函数对象。在SGI STL中，提供了以下hash函数：

struct hash<char*>
struct hash<const char*>
struct hash<char> 
struct hash<unsigned char> 
struct hash<signed char>
struct hash<short>
struct hash<unsigned short> 
struct hash<int> 
struct hash<unsigned int>
struct hash<long> 
struct hash<unsigned long>

　　也就是说，如果你的key使用的是以上类型中的一种，你都可以使用缺省的hash函数。当然你自己也可以定义自己的hash函数。对于自定义变量，你只能如此，例如对于string，就必须自定义hash函数。例如：

struct str_hash
{
        size_t operator()(const string& str) const
        {
                unsigned long __h = 0;
                for (size_t i = 0 ; i < str.size() ; i ++)
                __h = 5*__h + str[i];
                return size_t(__h);
        }
};
//如果你希望利用系统定义的字符串hash函数，你可以这样写：
struct str_hash
{
        size_t operator()(const string& str) const
        {
                return __stl_hash_string(str.c_str());
        }
};

在声明自己的哈希函数时要注意以下几点：

使用struct，然后重载operator().
返回是size_t
参数是你要hash的key的类型。
函数是const类型的。

　　在map中的比较函数，需要提供less函数。如果没有提供，缺省的也是less< Key> 。在hash_map中，要比较桶内的数据和key是否相等，因此需要的是是否等于的函数:equal_to< Key> 。先看看equal_to的源码：

//本代码可以从SGI STL
//先看看binary_function 函数声明，其实只是定义一些类型而已。
template <class _Arg1, class _Arg2, class _Result>
struct binary_function {
        typedef _Arg1 first_argument_type;
        typedef _Arg2 second_argument_type;
        typedef _Result result_type;
};
//看看equal_to的定义：
template <class _Tp>
struct equal_to : public binary_function<_Tp,_Tp,bool>
{
        bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
};

　　如果你使用一个自定义的数据类型，如struct mystruct, 或者const char* 的字符串，如何使用比较函数？使用比较函数，有两种方法. 第一种是：重载==操作符，利用equal_to;看看下面的例子：

struct mystruct
{
    int iID;
    int  len;
    bool operator==(const mystruct & my) const
    {
        return (iID==my.iID) && (len==my.len) ;
    }
};
//这样，就可以使用equal_to< mystruct>作为比较函数了。另一种方法就是使用函数对象。自定义一个比较函数体：

struct compare_str
{
    bool operator()(const char* p1, const char*p2) const
    {
        return strcmp(p1,p2)==0;
    }
};
//有了compare_str，就可以使用hash_map了。

typedef hash_map<const char*, string, hash<const char*>, compare_str> StrIntMap;

#include <hash_map>
//#include <ext/hash_map>
#include <string>
#include <iostream>

using namespace std;
using namespace __gnu_cxx;
/*
__gnu_cxx这是一个名子空间名（namespace）名，在GCC编译器使用的C++库中定义（名子空间的定义与一般变量不同，并不局限于某一文件）
定义这个名子空间的目的有二：一是将一些内部名子（编译器实现相关）与 std 空间隔离，二是为了实现一些公用的GNU扩展。
*/
//define the class
class ClassA
{
    public:
        ClassA(int a):c_a(a){}
        int getvalue()const
        {
            return c_a;
        }
        void setvalue(int a)
        {
            c_a=a;
        }
    private:
        int c_a;
};

//1 define the hash function
struct hash_A
{
    size_t operator()(const class ClassA & A) const
    {
        //  return  hash<int>(classA.getvalue());
        return A.getvalue();
    }
};

//2 define the equal function
struct equal_A
{
    bool operator()(const class ClassA & a1, const class ClassA & a2) const
    {
            return  a1.getvalue() == a2.getvalue();
    }
};

int main()
{
    hash_map<ClassA, string, hash_A, equal_A> hmap;
    ClassA a1(12);
    hmap[a1]="2019 07 21";
    ClassA a2(198877);
    hmap[a2]="2019 07 21 22:42";

    cout<<hmap[a1]<<endl;
    cout<<hmap[a2]<<endl;
    return 0;
}