关键字key对应一个存储位置f(key)。
查找时，根据这个对应的关系找到给定值key的映射f(key)，
若查找集合中存在这个记录，则必定在f(key)的位置上。
我们把这种对应关系f成为散列函数

// 默认的计算哈希的实现类
template<typename K>
class default_hash
{
public:
        int getHash(const K &key)
        {
               // 通用的计算key散列码的方式 用内存地址
               int size = sizeof(K);
               int sum = 0;
               char *p = (char*)&key;
               for (int i = 0; i < size; ++i)
               {
                       sum += (p[i] << i);  // h ello olleh
               }
               return sum;
        }
};
#if 0
template<>
class default_hash<string>
//这是错误的计算散列码的方式 是用ASCII值来计算的
{
public:
        int getHash(const string &key)
        {
               int hash = 0;
               for (int i = 0; i < key.length(); ++i)
               {
                       hash += (key[i] << i);
               }
               return hash;
        }
};
#endif
template<typename K, typename Hash = default_hash<K>>
class CHashTable
{
public:
        CHashTable(double loadFactor = 0.75)
               :mpTable(new Node[mprimeTable[0]])
               ,mall_bucket_num(mprimeTable[0])
               ,muse_bucket_num(0)
               ,mloadFactor(loadFactor)
        {}
        ~CHashTable()
        {
               delete[]mpTable;
               mpTable = nullptr;
        }
        void insert(const K &key) // 哈希表增加元素
        {
               double lf = muse_bucket_num * 1.0 / mall_bucket_num;
               cout << "loadfactor:" << lf << endl;
               if (lf > mloadFactor)
               {
                       resize();
               }
               int index = mhash.getHash(key) % mall_bucket_num;
               int index_stat = index;
               do
               {
                       if (USING != mpTable[index].mstate)
                       {
                              mpTable[index].mdata = key;
                              mpTable[index].mstate = USING;
                              muse_bucket_num++;
                              return;//报错用return 不要用break 避免公司其他人对代码进行添加
                       }
                       index = (index + 1) % mall_bucket_num;
               } while (index_stat != index);
        }
        void erase(const K &key)  // 哈希表删除元素
        {
               int index = mhash.getHash(key) % mall_bucket_num;
               int index_stat = index;
               do
               {
                       if (UNUSE == mpTable[index].mstate)
                       {
                              return;
                       }
                       if (USING == mpTable[index].mstate
                              && key == mpTable[index].mdata)
                       {
                              mpTable[index].mstate = USED;  //析构
                              muse_bucket_num--;
                              return;
                       }
                       index = (index + 1) % mall_bucket_num;
               } while (index_stat != index);
        }
        bool query(const K &key)  // 哈希表查找元素
        {
               int index = mhash.getHash(key) % mall_bucket_num;
               int index_stat = index;
               do
               {
                       if (USING == mpTable[index].mstate
                              && key == mpTable[index].mdata)
                       {
                              return true;
                       }
                       if (UNUSE == mpTable[index].mstate)
                       {
                              return false;
                       }
                       index = (index + 1) % mall_bucket_num;
               } while (index_stat != index);
               return false;
        }
private:
        enum STATE { USING, USED, UNUSE }; // 枚举桶的状态
        struct Node // 桶元素的类型
        {
               Node(K data = K())   // 不要写成K data = 0 不然就必须保证是整型类型了
                       :mstate(UNUSE)
                       ,mdata(data) {}
               STATE mstate;
               K mdata;
        };
        Node *mpTable; // 桶的数组
        int mall_bucket_num; // 桶的总数量
        int muse_bucket_num; // 已使用的桶数量
        double mloadFactor; // 加载因子
        Hash mhash; // 计算散列码的对象
        static int mprimeTable[4]; // 素数表
        static int mprimeIndex; // 素数表的下标
        void resize() // 哈希表扩容函数
        {//扩容是遍历旧的哈希表 所以muse_bucket_num数量是没变的
               mprimeIndex += 1;
               Node *ptmp = new Node[mprimeTable[mprimeIndex]];
               for (int i = 0; i < mall_bucket_num; i++)
               {
                       if (USING == mpTable[i].mstate)
                       {
                              int index = mhash.getHash(mpTable[i].mdata) %  mprimeTable[mprimeIndex];
                              int index_stat = index;
                              do
                              {
                                      if (UNUSE == ptmp[index].mstate)
                                      {
                                             ptmp[index].mdata = mpTable[i].mdata;
                                             ptmp[index].mstate = USING;
                                             break;
                                      }
                                      index = (index + 1) % mprimeTable[mprimeIndex];
                              } while (index_stat != index);
                       }
               }
               delete []mpTable;
               mpTable = ptmp;
               mall_bucket_num = mprimeTable[mprimeIndex];
        }
};
// {3, 7, 23, 53}
template<typename K, typename Hash>        //疑问3：模板类型在类外的使用
int CHashTable<K, Hash>::mprimeTable[4] = { 3, 7, 23, 53 };
template<typename K, typename Hash>
int CHashTable<K, Hash>::mprimeIndex = 0;
int main()
{
#if 0
        CHashTable<int> hashTable;
        for (int i = 0; i < 20; ++i)
        {
               hashTable.insert(rand() % 100);
        }
#endif
        CHashTable<string>  strHash;
        strHash.insert("aaa");
        strHash.insert("bbb");
        strHash.insert("ccc");
        strHash.insert("dda");
        class Student
        {
        public:
               Student(string name="", double score=0.0)
                       :_name(name), _score(score) {}
               bool operator==(const Student &stu)const
               {
                       return _name == stu._name;
               }
        private:
               string _name;
               double _score;
        };
        CHashTable<Student> studentHash;
        studentHash.insert(Student("张三", 98.5));
        studentHash.insert(Student("李四", 99.5));
        studentHash.insert(Student("王五", 89.5));
        cout << studentHash.query(Student("张三", 98.5)) << endl;
        return 0;
}![

#include "pch.h"
#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <unordered_map> // 无序的映射表
using namespace std;

/*
顺序容器
vector:向量容器  内存2倍扩容的数组
list：链表容器   双向的循环链表


关联容器 set集合(key)   map映射表(key-value)
无序的关联容器（哈希表 增删查O(1)）

有序的关联容器（红黑树 增删查O(logn)）
*/

//定义链式哈希表 有keyK 信息value V
//我们要用数组和链表 直接使用vector即可，在vector内放list类型
template<typename K, typename V>
struct Pair//vector<list>只需要一个参数 所以这里要把K,V封装成结构体
{
    // K() 零构造  如果是整型的话，这里就直接初始化为0
    Pair(const K key = K(), const V val = V())
        :first(key), second(val) {}
    K first;
    V second;
};
// Make_Pair函数模板，封装了Pair对象的创建
//比较方便 不用在调用的时候还得写Pair<int, string>(24, "zhang san")
template<typename K, typename V>
Pair<K, V> Make_Pair(const K key = K(), const V val = V())
{
    return Pair<K, V>(key, val);
}

// 不允许存储重复的key值的  34-lisi  34-zhang san
//发现重复的用新值把旧值覆盖掉
template<typename K, typename V>
class HashMap
{
public:
    // 哈希表初始化长度为3 加载因子0.75
    HashMap(int size = 3, double loadfactor = 0.75)
        : _usedBuckets(0)
        , _loadFactor(loadfactor)
    {
        // 要开辟长度为size的哈希表
        //reserve只开空间 但是没有放链表（vector封装的数组）进去
        // _buckets.reserve(size)   _buckets.resize(size)
        // resize不仅给vector容器开辟size个空间，还放了size个链表进去了
        _buckets.resize(size);
    }
    // 哈希表增加操作
    void insert(const Pair<K, V> &pair)
    {
        // 检查一下加载因子
        double lf = _usedBuckets*1.0 / _buckets.size();
        //默认除法得到的是整数 所以要前面乘1.0 这样能得到浮点数
        cout << "lf:" << lf << endl;
        if (lf >= _loadFactor)
        {
            expand();
        }


        int index = pair.first % _buckets.size();
        // list<Pair<K,V>>
        auto &mylist = _buckets[index];
    //利用哈希表这个对象 构建list对象
        if (mylist.empty())  // mylist[]
        {
            _usedBuckets++;//表示有个桶被占用
        }
        else
        {
            auto it = mylist.begin(); // Pair<K,V>
            //vector底层封装了迭代器 所以直接用即可
            for (; it != mylist.end(); ++it)
            {
                if (it->first == pair.first)
                {
                    it->second = pair.second;//传进的value值给了哈希表当前这个key对应的value上
                    return;
                }
            }
        }
        mylist.push_back(pair);//如果没有找到对应的key键值对 就自己插进去一对
    }
    // 哈希表删除操作
    void erase(const K &key)
    {
        int index = key % _buckets.size();
        // list<Pair<K,V>>
        auto &mylist = _buckets[index];
        //注意定义引用变量是因为要改哈希表里面的元素 而不是局部变量
        if (mylist.empty())
        {
            return;
        }


        auto it = mylist.begin(); // Pair<K,V>
        for (; it != mylist.end(); ++it)
        {
            if (it->first == key)
            {
                mylist.erase(it);
                if (mylist.empty())
                {
                    _usedBuckets--;
                }
                return;
            }
        }
    }
    // 哈希表的查询操作  map[34] = value
    // cout << map[34] << endl;
    // map[34] = "zhang san"  [34, "zhang san"]
    //所以这个[ ]一共代表了查找 覆盖值 增加一个键值对的功能
    V& operator[](const K &key)
    {
        int index = key % _buckets.size();
        // list<Pair<K,V>>
        auto &mylist = _buckets[index];
        if (!mylist.empty())
        {
            auto it = mylist.begin(); // Pair<K,V>
            for (; it != mylist.end(); ++it)
            {
                if (it->first == key)
                {
                    return it->second;
                }
            }
        }
       
        //如果这个链表里没有对应的 增加一个新的key-value对
        Pair<K, V> p(key);//先通过传入的先构造一个键值对
        mylist.push_back(p);
        return mylist.back().second;//容器里有back方法  返回哈希表里键值对的second的值    
    }
private:
    // 哈希表的桶
    vector<list<Pair<K, V>>> _buckets;
    // 已占用的桶的个数
    int _usedBuckets;
    // 加载因子 0.75
    double _loadFactor;


    // 哈希表的扩容操作  2n+1进行扩容
    void expand()
    {//直接扩容会面临哈希表失效
        // 容器的swap交换操作效率很高
        vector<list<Pair<K, V>>> old;//定义一个old容器
        old.swap(_buckets);//然后进行交换操作，就是成员变量交换
//此时old是原来的哈希表 现在这个bucket是个空的
        _buckets.resize(old.size() * 2 + 1);//给这个哈希表扩容
        _usedBuckets = 0;//已用的桶变为0


        // 遍历老的哈希表，把老的哈希桶中链表的节点直接拿到新哈希表中
        auto vit = old.begin();//用迭代器遍历  也可以用下标遍历
        for (; vit != old.end(); ++vit) // 遍历vector的数组
        {
            if (!vit->empty()) // 遍历vector里面存的list
            {
                auto lit = vit->begin();
                for (; lit != vit->end(); ++lit)
                {
                    // #1 求相应链表的k
                    int index = lit->first % _buckets.size();
                    // #2 list的splice分片函数
                    if (_buckets[index].empty())
                    {
                        _usedBuckets++;
                    }//把这个链表拿出来放在扩容后的哈希表里
                    _buckets[index].push_back(*lit);
                }
            }
        }
    }
};
int main()
{
    HashMap<int, string> map;
    map.insert(Pair<int, string>(24, "zhang san"));//麻烦的写法
    map.insert(Make_Pair(25, string("li si")));//用函数模板 自动推演出类型
    map.insert({26, "wang wu"});//改版以后的写法 平时写成这样既可
    map[27] = "gao yang";
    map.insert({ 56, "wang wu" });
    map.insert({ 89, "wang wu" });
    map.insert({ 345, "wang wu" });
    map.insert({ 678, "wang wu" });
    map.insert({ 78, "wang wu" });


    // unordered_set 集合    只存key 不存储value了    
    unordered_map<int, string> map1; // key-value
     


    /*cout << map[24] << endl;
    cout << map[27] << endl;
    map.erase(27);
    cout << map[27] << endl;*/
}

............
       bool find(const K &key)  // 哈希表查找元素
        {
               int index = getHash(key) % mhashTable.size();
               list<K> &mylist = mhashTable[index];
               for (K &k : mylist)
               {
                       if (k == key)
                              return true;
               }
               return false;
        }
private:
        vector<list<K>> mhashTable; // 链式哈希表
        int muse_bucket_num; // 已使用的桶数量
        double mloadFactor; // 加载因子
        static int mprimeTable[4]; // 素数表
        static int mprimeIndex; // 素数表的下标
       
        int getHash(const K &key)
        {
               // 通用的计算key散列码的方式
               int size = sizeof(K);
               int sum = 0;
               char *p = (char*)&key;
               for (int i = 0; i < size; ++i)
               {
                       sum += (p[i] << i);  // hello olleh
               }
               return sum;
        }
};

int main()
{       CHashTable<string>  strHash;
        strHash.insert("aaa");
        strHash.insert("bbb");
        strHash.insert("ccc");
        strHash.insert("dda");
        class Student
        {
        public:
               Student(string name = "", double score = 0.0)
                       :_name(name), _score(score) {}
//等号运算符重载 解决内存地址不一样无法比较的问题
               bool operator==(const Student &stu)const
               {
                       return _name == stu._name;
               }
//
        private:
               string _name;
               double _score;
        };
        CHashTable<Student> studentHash;
        studentHash.insert(Student("张三", 98.5));
        studentHash.insert(Student("李四", 99.5));
        studentHash.insert(Student("王五", 89.5));
        cout << studentHash.find(Student("张三", 98.5)) << endl;
//当调用的是find-->gethash-->传入的是张三这个对象 gethash把这个对象的地址进行引用
//所以在find函数里我进行比较的是散列表里张三的地址和传入的这个对象张三的地址
//这两个地址大多数情况是不一样的 所以我们需要使用==运算符重载 直接比较张三这个名字
        return 0;
}