#include <iostream>
#include <unordered_set>  // 使用unordered_set需要包含此头文件
using namespace std;

int main() {
    // 创建一个存储整数的unordered_set
    unordered_set<int> mySet;

    // 插入一些元素
    mySet.insert(10);
    mySet.insert(20);
    mySet.insert(30);
    mySet.insert(20);  // 重复插入20，因为20已存在，这次插入会失败

    // 使用insert的返回值来检查是否真的插入了
    auto result = mySet.insert(20);
    if (result.second == false) {
        cout << "20已经存在，第二次插入失败了" << endl;
    }

    // 打印当前集合的大小
    cout << "集合中元素个数: " << mySet.size() << endl;  // 输出3

    // 查找元素：find返回迭代器，如果等于end()说明没找到
    int key = 20;
    auto it = mySet.find(key);
    if (it != mySet.end()) {
        cout << "找到了元素: " << *it << endl;
    } else {
        cout << "没有找到元素: " << key << endl;
    }

    // 另一种查找方法：count
    if (mySet.count(30) > 0) {
        cout << "30存在于集合中" << endl;
    }

    // 删除元素
    mySet.erase(10);  // 删除值为10的元素
    cout << "删除后大小: " << mySet.size() << endl;  // 输出2

    // 遍历集合（注意顺序是不确定的）
    cout << "当前集合中的元素:";
    for (int x : mySet) {
        cout << " " << x;
    }
    cout << endl;

    // 清空集合
    mySet.clear();
    cout << "清空后是否为空: " << (mySet.empty() ? "是" : "否") << endl;

    return 0;
}

20已经存在，第二次插入失败了
集合中元素个数: 3
找到了元素: 20
30存在于集合中
删除后大小: 2
当前集合中的元素: 30 20
清空后是否为空: 是

# Python的set就是哈希集合
my_set = set()  # 创建一个空集合

# 插入元素
my_set.add(10)
my_set.add(20)
my_set.add(30)
result = my_set.add(20)  # 重复添加20，不会报错，但集合仍然只有一个20
# 注意：add没有返回值，但我们可以通过len检查

print("集合中元素个数:", len(my_set))  # 输出3

# 查找元素：用in运算符
key = 20
if key in my_set:
    print("找到了元素:", key)
else:
    print("没有找到元素:", key)

# also可以用count? 实际上可以用in, 没有count方法, 但可以:
print("20是否存在:", key in my_set)

# 删除元素
my_set.discard(10)  # discard不会报错即使不存在，remove会报错
# 或者 my_set.remove(10)  # 如果10不存在会抛出KeyError
print("删除后大小:", len(my_set))  # 输出2

# 遍历集合（顺序不确定）
print("当前集合中的元素:", end=" ")
for x in my_set:
    print(x, end=" ")
print()

# 清空集合
my_set.clear()
print("清空后是否为空:", len(my_set) == 0)  # 输出True

book1 = {"apple", "banana", "cherry", "date"}
book2 = {"banana", "date", "elderberry", "fig"}

# 并集：两本书里出现过的所有生词
all_words = book1 | book2   # 或 book1.union(book2)
print("所有生词:", all_words)

# 交集：两本书都出现的生词
common = book1 & book2   # 或 book1.intersection(book2)
print("共同生词:", common)

# 差集：只在第一本书里出现的生词
only_book1 = book1 - book2   # 或 book1.difference(book2)
print("只在第一本中:", only_book1)

# 对称差：两本书中不重复出现的生词
unique_per_book = book1 ^ book2   # 或 book1.symmetric_difference(book2)
print("各自独有的生词:", unique_per_book)

所有生词: {'cherry', 'elderberry', 'fig', 'date', 'banana', 'apple'}
共同生词: {'date', 'banana'}
只在第一本中: {'cherry', 'apple'}
各自独有的生词: {'elderberry', 'cherry', 'apple', 'fig'}

struct Student {
    int id;
    string name;
    // 需要提供相等比较
    bool operator==(const Student& other) const {
        return id == other.id;
    }
};

// 自定义哈希函数
struct StudentHash {
    size_t operator()(const Student& s) const {
        return hash<int>()(s.id);
    }
};

unordered_set<Student, StudentHash> roster;

#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;

int main() {
    // 假设已登记的学号列表（可能有重复）
    vector<int> registered = {101, 102, 103, 101, 104, 102, 105};
    
    // 使用unordered_set去重
    unordered_set<int> unique_ids;
    for (int id : registered) {
        // insert返回pair，second表示是否插入成功
        auto result = unique_ids.insert(id);
        if (!result.second) {
            cout << "学号 " << id << " 已存在，跳过重复" << endl;
        }
    }

    cout << "最终不重复的学号个数: " << unique_ids.size() << endl;
    cout << "学号列表: ";
    for (int id : unique_ids) {
        cout << id << " ";
    }
    cout << endl;

    // 快速查找某个学号是否存在
    int target = 103;
    if (unique_ids.find(target) != unique_ids.end()) {
        cout << "学号 " << target << " 在集合中" << endl;
    }

    return 0;
}

学号 101 已存在，跳过重复
学号 102 已存在，跳过重复
最终不重复的学号个数: 5
学号列表: 105 104 103 102 101 
学号 103 在集合中