std::unordered_multiset::rehash

#include <unordered_set>

void rehash(size_type count);

Thiết lập số lượng bucket trong bảng băm của std::unordered_multiset thành ít nhất count (tham số truyền vào). Việc này sẽ dẫn đến quá trình băm lại (rehashing), tức là tất cả các phần tử sẽ được phân phối lại vào các bucket dựa trên số lượng bucket mới và hàm băm.

Tham số

`count`

Số lượng bucket tối thiểu mà bạn muốn std::unordered_multiset sử dụng.

Giá trị trả về

Không có giá trị trả về

Đặc điểm

Thiết lập số lượng bucket tối thiểu: rehash(count) yêu cầu std::unordered_multiset sử dụng ít nhất count bucket. Số lượng bucket thực tế có thể lớn hơn count tùy thuộc vào trình triển khai và thuật toán được sử dụng.
Băm lại (rehashing): Khi gọi rehash(), std::unordered_multiset sẽ băm lại tất cả các phần tử hiện có và phân phối chúng vào các bucket mới dựa trên số lượng bucket mới và hàm băm.
Có thể tốn kém: Rehashing là một thao tác tốn kém vì nó liên quan đến việc băm lại và di chuyển tất cả các phần tử.
Làm thay đổi iterator: Rehashing chắc chắn sẽ làm thay đổi (invalidate) tất cả các iterator đang trỏ đến các phần tử trong std::unordered_multiset.
Không đảm bảo duy trì thứ tự: std::unordered_multiset không đảm bảo thứ tự của các phần tử, và sau khi rehash, thứ tự duyệt qua các phần tử có thể thay đổi.
Nên gọi trước khi chèn nhiều phần tử: Nếu bạn biết trước số lượng phần tử mà bạn sẽ chèn vào std::unordered_multiset, bạn nên gọi rehash() hoặc reserve() trước khi chèn để tránh việc rehashing tự động xảy ra nhiều lần trong quá trình chèn, tối ưu hiệu suất.
Liên quan đến load_factor() và max_load_factor(): rehash() có liên quan đến hệ số tải (load factor) và hệ số tải tối đa (max_load_factor()). Khi hệ số tải vượt quá max_load_factor(), std::unordered_multiset sẽ tự động thực hiện rehashing.
Có thể ném ngoại lệ: Nếu việc cấp phát bộ nhớ thất bại, rehash() có thể ném ra ngoại lệ std::bad_alloc. Ngoài ra, nếu copy constructor, move constructor, hash function, equal function, hoặc destructor của value_type ném ngoại lệ, rehash() cũng sẽ ném ngoại lệ.
Độ phức tạp: Độ phức tạp của rehash() là O(n), với n là số phần tử trong std::unordered_multiset.

Phân biệt với reserve()

rehash(n): thiết lập số lượng bucket ít nhất là n.
reserve(n): yêu cầu std::unordered_multiset cấp phát đủ bộ nhớ để chứa ít nhất n phần tử mà không cần phải rehash.

Ví dụ

#include <iostream>
#include <unordered_set>

int main() {
  std::unordered_multiset<int> myumset;

  std::cout << "Initial bucket_count: " << myumset.bucket_count() << '\n';

  myumset.rehash(20); // Yêu cầu unordered_multiset sử dụng ít nhất 20 bucket

  std::cout << "Bucket_count after rehash(20): " << myumset.bucket_count() << '\n';

  // Chèn thêm phần tử để thấy số bucket thay đổi
  for (int i = 0; i < 50; ++i) {
    myumset.insert(i);
  }

  std::cout << "Bucket_count after adding elements: " << myumset.bucket_count() << '\n';
  std::cout << "Load factor: " << myumset.load_factor() << '\n';

  return 0;
}

Các hàm liên quan


reserve	Yêu cầu thay đổi số lượng phần tử mà std::unordered_multiset có thể chứa mà không cần phải rehash
bucket_count	Trả về số lượng bucket (hay còn gọi là giỏ) hiện tại trong std::unordered_multiset
max_load_factor	Truy vấn hoặc thiết lập hệ số tải tối đa (maximum load factor) của std::unordered_multiset
size	Trả về số lượng phần tử hiện có trong std::unordered_multiset

Tham số​

count​

Giá trị trả về​

Đặc điểm​

Ví dụ​

Các hàm liên quan​