Toán tử quan hệ

#include <unordered_map>

// Với a và b là hai unordered_map cùng kiểu:
template <class Key, class T, class Hash, class Pred, class Alloc>
bool operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                const unordered_map<Key, T, Hash, Pred, Alloc>& b);

template <class Key, class T, class Hash, class Pred, class Alloc>
bool operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& a,
                const unordered_map<Key, T, Hash, Pred, Alloc>& b);

So sánh hai std::unordered_map với nhau.

Tham số

a, b

• Hai std::unordered_map cần so sánh. Chúng phải có cùng kiểu tham số.

Giá trị trả về

bool

• Trả về true nếu biểu thức so sánh là đúng, false nếu sai.

Đặc điểm

1. So sánh nội dung, không so sánh thứ tự: Các toán tử quan hệ so sánh nội dung của hai std::unordered_map, không quan tâm đến thứ tự cụ thể của các phần tử bên trong (vì std::unordered_map không lưu trữ phần tử theo thứ tự).
2. Phụ thuộc vào toán tử == của key và value: Việc so sánh các phần tử của std::unordered_map sử dụng toán tử == của key_type và mapped_type. Do đó, kiểu key_type và mapped_type của std::unordered_map phải hỗ trợ toán tử ==.
3. Phụ thuộc vào key_eq(): Việc xác định hai phần tử có bằng nhau hay không còn phụ thuộc vào hàm key_eq() (equality comparison function) của std::unordered_map.
4. Chỉ hỗ trợ == và !=: std::unordered_map chỉ hỗ trợ toán tử == và !=, không hỗ trợ các toán tử so sánh thứ tự <, >, <=, >= vì các phần tử không được sắp xếp.
5. Không làm thay đổi map: Các toán tử này là const, không làm thay đổi nội dung của 2 map đang được so sánh.
6. Độ phức tạp:
   • Trường hợp tốt nhất (hai map khác kích thước): O(1).
   • Trường hợp trung bình: O(n), với n là số phần tử trong map.
   • Trường hợp xấu nhất: O(n²).

Ví dụ

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
  std::unordered_map<std::string, int> umap1 = {{"apple", 1}, {"banana", 2}};
  std::unordered_map<std::string, int> umap2 = {{"banana", 2}, {"apple", 1}};
  std::unordered_map<std::string, int> umap3 = {{"apple", 1}, {"grape", 3}};
  std::unordered_map<std::string, int> umap4 = {{"apple", 1}};

  std::cout << "umap1 == umap2: " << (umap1 == umap2) << '\n'; // Output: umap1 == umap2: 1 (true) - cùng phần tử, không quan trọng thứ tự
  std::cout << "umap1 != umap3: " << (umap1 != umap3) << '\n'; // Output: umap1 != umap3: 1 (true) - phần tử khác nhau
  std::cout << "umap1 == umap4: " << (umap1 == umap4) << '\n'; // Output: umap1 == umap4: 0 (false) - kích thước khác nhau
  std::cout << "umap1 != umap4: " << (umap1 != umap4) << '\n'; // Output: umap1 != umap4: 1 (true) - kích thước khác nhau

  return 0;
}

Các hàm liên quan

equal_range	Trả về một cặp iterator xác định phạm vi các phần tử trong std::unordered_map có key bằng với giá trị key cho trước
=	Gán nội dung của một std::unordered_map khác hoặc một initializer_list cho std::unordered_map hiện tại