Hash-table

struct Node {
    string key;
    bool deleted;
    Node(string _key);
};

Node::Node(string _key) : key(_key), deleted(false){}


class HashTable {
private:
    int size = 0;
    int countKeys = 0;
    vector<Node> table;

    int GetHash(string key, int mod) const;
    void Rehash();

public:
    HashTable();
    ~HashTable();

    bool Insert(string key);
    bool Erase(string key);
    bool Find(string key);
};

HashTable::HashTable() : size(8), countKeys(0) {
    table.resize(8, Node("empty"));
}

HashTable::~HashTable() {
    size = countKeys = 0;
    table.clear();
}

int HashTable::GetHash(string key, int mod) const {
    int hash = 0;
    int base = 11;
    for (int i = 0; i < key.size(); ++i) {
        hash = (hash * base + key[i]) % mod;
    }
    return hash;
}

void HashTable::Rehash() {
    int newSize = size * 2;
    vector<Node> newTable(newSize, Node("empty"));
    for (int i = 0; i < size; i++) {
        if (table[i].key != "empty" && !table[i].deleted) {
            int hash = GetHash(table[i].key, newSize);
            int k = 0;
            while (newTable[hash].key != "empty" && k < newSize) {
                hash = (hash + (k * k) % newSize) % newSize;
                k++;
            }
            newTable[hash] = table[i];
        }
    }
    table = newTable;
    size = newSize;
}

bool HashTable::Insert(string key) {
    if (((double)countKeys / (double)size) >= (double)0.75) {
        Rehash();
    }

    int hash = GetHash(key, size);
    int i = 0;
    int firstDeleted = -1;
    while (table[hash].key != "empty" && i < size) {
        if (table[hash].key == key && !table[hash].deleted) {
            return false;
        }
        if (table[hash].deleted && firstDeleted < 0) {
            firstDeleted = hash;
        }
        i++;
        hash = (hash + (i * i) % size) % size;
    }

    if (firstDeleted < 0) {
        table[hash] = Node(key);
    } else {
        table[firstDeleted].key = key;
        table[firstDeleted].deleted = false;
    }
    countKeys++;
    return true;
}

bool HashTable::Erase(string key) {
    int hash = GetHash(key, size);
    int i = 0;
    while (table[hash].key != "empty" && i < size) {
        if (table[hash].key == key && !table[hash].deleted) {
            table[hash].deleted = true;
            countKeys--;
            return true;
        }
        i++;
        hash = (hash + (i * i) % size) % size;
    }
    return false;
}

bool HashTable::Find(string key) {
    int hash = GetHash(key, size);
    int i = 0;
    while (table[hash].key != "empty" && i < size) {
        if (table[hash].key == key && !table[hash].deleted) {
            return true;
        }
        i++;
        hash = (hash + (i * i) % size) % size;
    }
    return false;
}