哈希表

1.我们在网站上注册账号时，当填好用户名后，系统都会判断用户名是否已被使用，如果已被使用，系统就会提示该用户名已被注册。系统是如何检测用户名是否被使用的？

可以用哈希表来解决这个问题。哈希表又叫散列表，关键值通过哈希函数映射到数组上，查找时通过关键值直接访问数组。在上面的例子里，我们将用户名通过哈希函数映射成一个整数，也就是数组的存储位置，在检测时用同样方法计算出存储位置，如果位置上已有元素则表示用户名已经被注册。

哈希函数指的是关键值和存储位置建立的对应关系，查找时只要根据这个关系就能找到目标位置。一般我们只要通过一次查找就能找到目标位置，但有些关键字需要多次比较和查找才能找到，这是为什么呢？因为哈希表里，可能存在关键字不同但是哈希地址相同的情况，也就是冲突。一般情况下，冲突是不可避免的，因为关键字集合往往比哈希地址集合大很多。

提高哈希表的查找效率，关键在与哈希函数的构造和解决冲突的方法。哈希函数的构造方法有很多种，我们应该如何构造优秀的哈希函数来减少冲突呢？如果发生了冲突，我们该如何处理冲突，减少比较次数提高查找效率呢？

2.性质

• 哈希表里的冲突只能减少，是不可避免的
• 哈希函数构造的好坏会影响查找效率
• 优秀的处理冲突方法可以减少比较次数，提高查找效率

3.设计哈希函数没有统一的方法，同一个哈希函数不一定能适用所有问题，其产生的影响也是不一样的。哈希函数的设计又是至关重要的，那么我们该如何设计呢？一般来说，设计哈希函数时要达到两个要求：计算简单，计算复杂的哈希函数会增加查询的时间；关键字尽可能地均分到存储地址上，这样可以减少冲突。

4.哈希表的构造，插入，查询，和重建

#include <iostream>
#include <string>
using namespace std;
class HashTable {
private:
    string *elem;
    int size;
public:
    HashTable() {
        size = 2000;
        elem = new string[size];
        for (int i = 0; i < size; i++) {
            elem[i] = "#";
        }
    }
    ~HashTable() {
        delete[] elem;
    }
    int hash(string& index) {
        int code = 0;
        for (size_t i = 0; i < index.length(); i++) {
            code = (code * 256 + index[i] + 128) % size;                    //避免负数所以加上128，相加时用的ASCII码的值
        }
        return code;
    }
    bool search(string& index, int& pos, int& times) {                      //开放地址法
        pos = hash(index);
        times = 0;                                                         //记录冲突次数
        while (elem[pos] != "#" && elem[pos] != index) {
            times++;
            if (times < size) {
                pos = (pos + 1) % size;
            } else {
                return false;
            }
        }
        if (elem[pos] == index) {
            return true;
        } else {
            return false;
        }
    }
    int insert(string& index) {
        int pos, times;
        if (search(index, pos, times)) {
            return 2;
        } else if (times < size / 2) {
            elem[pos] = index;
            return 1;
        } else {
            recreate();
            return 0;
        }
    }
    void recreate(){
        string *temp_elem;
        temp_elem=new string[size];
        for(int i=0;i<size;i++){
            temp_elem[i]=elem[i];
        }
        int copy_size=size;
        size=size*2;
        delete[]elem;
        elem=new string[size];
        for(int i=0;i<size;i++){
            elem[i]="#";
        }
        for(int i=0;i<copy_size;i++){
            if(temp_elem[i]!="#"){
                insert(temp_elem[i]);
            }
        }
        delete[]temp_elem;
    }
};
int main() {
    HashTable hashtable;
    string buffer;
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> buffer;
        int ans = hashtable.insert(buffer);
        if (ans == 0) {
            cout << "insert failed!" << endl;
        } else if (ans == 1) {
            cout << "insert success!" << endl;
        } else if (ans == 2) {
            cout << "It already exists!" << endl;
        }
    }
    int temp_pos, temp_times;
    cin >> buffer;
    if (hashtable.search(buffer, temp_pos, temp_times)) {
        cout << "search success!" << endl;
    } else {
        cout << "search failed!" << endl;
    }
    return 0;
}

5.应用：忽略大小写筛选用户名

#include <iostream>
#include <string>
#include <cctype>
#include <algorithm>
using namespace std;
class HashTable {
private:
    string *elem;
    int size;
public:
    HashTable() {
        size = 300000;
        elem = new string[size];
        for (int i = 0; i < size; i++) {
            elem[i] = "#";
        }
    }
    ~HashTable() {
        delete[] elem;
    }
    int hash(string& index) {
        int code = 0;
        for (size_t i = 0; i < index.length(); i++) {
            code = (code * 256 + index[i] + 128) % size;
        }
        return code;
    }
    bool search(string& index, int& pos, int& times) {
        pos = hash(index);
        times = 0;
        while (elem[pos] != "#" && elem[pos] != index) {
            times++;
            if (times < size) {
                pos = (pos + 1) % size;
            } else {
                return false;
            }
        }
        if (elem[pos] == index) {
            return true;
        } else {
            return false;
        }
    }
    int insert(string& index) {
        int pos, times;
        if (search(index, pos, times)) {
            return 2;
        } else if (times < size / 2) {
            elem[pos] = index;
            return 1;
        } else {
            recreate();
            return 0;
        }
    }
    void recreate(){
        string *temp_elem;
        temp_elem=new string[size];
        for(int i=0;i<size;i++){
            temp_elem[i]=elem[i];
        }
        int copy_size=size;
        size=size*2;
        delete[]elem;
        elem=new string[size];
        for(int i=0;i<size;i++){
            elem[i]="#";
        }
        for(int i=0;i<copy_size;i++){
            if(temp_elem[i]!="#"){
                insert(temp_elem[i]);
            }
        }
        delete[]temp_elem;
    }
};
int main() {
    HashTable hashtable;
    string buffer;
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> buffer;
        transform(buffer.begin(),buffer.end(),buffer.begin(),::tolower);  
        int ans = hashtable.insert(buffer);
        if (ans == 0) {
            cout << "No" << endl;
        } else if (ans == 1) {
            cout << "No" << endl;
        } else if (ans == 2) {
            cout << "Yes" << endl;
        }
    }
    
    return 0;
}