C++中Hash表擴容機制

在C++中，哈希表（Hash Table）是一種非常重要的數據結構，它提供了快速的插入、刪除和查找操作。然而，當哈希表中的元素數量增加到一定程度時，為了保持操作的效率，我們需要對哈希表進行擴容。下面是一個簡單的C++哈希表擴容機制的實現：

1. 首先，定義一個哈希表類（HashTable）：

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>

class HashTable {
public:
    HashTable(size_t size);
    ~HashTable();

    void insert(int key);
    bool remove(int key);
    bool search(int key) const;

private:
    struct Entry {
        int key;
        bool occupied;
        Entry() : occupied(false) {}
    };

    size_t size_;
    size_t capacity_;
    std::vector<std::list<Entry>> table_;

    size_t hash(int key) const;
    void rehash(size_t new_capacity);
};

2. 實現哈希表類的構造函數和析構函數：

HashTable::HashTable(size_t size) : size_(0), capacity_(size), table_(size) {}

HashTable::~HashTable() {}

3. 實現插入操作：

void HashTable::insert(int key) {
    if (search(key)) {
        return;
    }

    size_t index = hash(key);
    for (auto& entry : table_[index]) {
        if (!entry.occupied) {
            entry.key = key;
            entry.occupied = true;
            size_t new_capacity = capacity_ * 2;
            rehash(new_capacity);
            return;
        }
    }

    table_[index].push_back({key, true});
    size_t new_capacity = capacity_ * 2;
    rehash(new_capacity);
}

4. 實現刪除操作：

bool HashTable::remove(int key) {
    size_t index = hash(key);
    for (auto it = table_[index].begin(); it != table_[index].end(); ++it) {
        if (it->key == key) {
            it->occupied = false;
            size_t new_capacity = capacity_ / 2;
            rehash(new_capacity);
            return true;
        }
    }
    return false;
}

5. 實現查找操作：

bool HashTable::search(int key) const {
    size_t index = hash(key);
    for (const auto& entry : table_[index]) {
        if (entry.key == key) {
            return true;
        }
    }
    return false;
}

6. 實現哈希函數和擴容操作：

size_t HashTable::hash(int key) const {
    return key % capacity_;
}

void HashTable::rehash(size_t new_capacity) {
    std::vector<std::list<Entry>> new_table(new_capacity);
    for (const auto& bucket : table_) {
        for (const auto& entry : bucket) {
            if (entry.occupied) {
                size_t new_index = hash(entry.key);
                new_table[new_index].push_back(entry);
            }
        }
    }

    capacity_ = new_capacity;
    table_ = std::move(new_table);
}

這個簡單的實現中，當哈希表的負載因子（已存儲元素數量與總容量的比值）超過0.5時，就會觸發擴容操作。擴容操作會將哈希表的總容量加倍，并將所有元素重新插入新的哈希表中。這樣可以確保哈希表的性能在元素數量增加時保持在一個較高的水平。