unordered_map<string, int> score;  //  声明一个哈希表
score["XiaoMing"] = 85;  // 初始化5个键值对
score["LiHua"] = 92;
score["ZhangSan"] = 76;
score["WangYing"] = 68;
score["ZhaoFei"] = 98;

// 1. 使用增强for循环遍历
for (auto& pair : score) {
    cout << pair.first << ": " << pair.second << endl;
}
// 或者
for (auto& [key, value] : score) {
    cout << key << ": " << value << endl;
}

// 2. 使用迭代器遍历
for (auto it = score.begin(); it != score.end(); ++it) {
    cout << it->first << ": " << it->second << endl;
}

HashMap<String, Integer> score = new HashMap<>(); 
score.put("XiaoMing", 85);
score.put("LiHua", 92);
score.put("ZhangSan", 76);
score.put("WangYing", 68);
score.put("ZhaoFei", 98);

// 1. 使用增强for循环遍历
for (Map.Entry<String, Integer> entry : score.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 2. 使用迭代器遍历
Iterator<Map.Entry<String, Integer>> iterator = score.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 3. 使用forEach遍历
score.forEach((key, value) -> System.out.println(key + ": " + value));

score = {
    "XiaoMing": 85,
    "LiHua": 92,
    "ZhangSan": 76,
    "WangYing": 68,
    "ZhaoFei": 98
}

# score.items 返回键值对的数组，故可以遍历items
print(score.items())

# 1. 遍历 score.items
for key, value in score.items():
    print(key, value)

# 2. 直接遍历score取出的是key,可以通过score[key] 取值
for key in score:
    print(key)

# 3. 只遍历 key
for key in score.keys():
    print(key)

# 4. 只遍历值
for value in score.values():
    print(value)    

// 声明一个哈希表集合
unordered_set<string> name;

// 插入元素   
name.insert("XiaoMing");  
name.insert("LiHua");
name.insert("ZhangSan");

// 查找元素
if (name.find("LiHua") != name.end()) {  // 存在 "LiHua"，返回 true
    // 存在的操作逻辑
    cout << "LiHua is in the set." << endl;
} else {
    // 不存在的操作逻辑
    cout << "LiHua is not in the set." << endl;
}

// 修改元素
// 由于集合中只存储键，只需要删除元素后插入新元素即可。

// 判断元素是否存在
cout << name.count("LiHua") << '\n';  // 存在 "LiHua"，返回 1，不存在返回 0


// 删除元素
name.erase("LiHua");  // 删除指定键的元素
name.clear();  // 清空集合
cout << name.count("LiHua") << '\n';  // 存在 "LiHua"，返回 1，不存在返回 0

// 声明一个哈希表集合
HashSet<String> name = new HashSet<>();

// 插入元素
name.add("XiaoMing");
name.add("LiHua");

// 查找元素
if (name.contains("LiHua")) {  // 存在 "LiHua"，返回 true
    // 存在的操作逻辑
    System.out.println("LiHua is in the set.");
} else {
    // 不存在的操作逻辑
    System.out.println("LiHua is not in the set.");
}

// 修改元素
// 由于集合中只存储键，只需要删除元素后插入新元素即可。

// 判断元素是否存在
System.out.println(name.contains("LiHua") ? 1 : 0);  // 存在 "LiHua"，返回 1，不存在返回 0

// 删除元素
name.remove("LiHua");  // 删除指定键的元素
name.clear();  // 清空集合
System.out.println(name.contains("LiHua")? 1 : 0);  // 存在 "LiHua"，返回 1，不存在返回 0

# 声明一个哈希表集合
name = set()

# 插入元素
name.add("XiaoMing")
name.add("LiHua")

# 查找元素
if "LiHua" in name:  # 存在 "LiHua"，返回 true
    # 存在的操作逻辑
    print("LiHua is in the set.")
else:
    # 不存在的操作逻辑
    print("LiHua is not in the set.")

# 修改元素
# 由于集合中只存储键，只需要删除元素后插入新元素即可。

# 判断元素是否存在
print(1 if "LiHua" in name else 0)  # 存在 "LiHua"，返回 1，不存在返回 0

# 删除元素
name.remove("LiHua")  # 删除指定键的元素
name.clear()  # 清空集合
print(1 if "LiHua" in name else 0)  # 存在 "LiHua"，返回 1，不存在返回 0

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode*> exist;
        exist.insert(headA);
        while (headA->next != NULL) {
            headA = headA->next;
            exist.insert(headA);
        }
        if (exist.count(headB)) {
            return headB;
        }
        while (headB->next != NULL) {
            headB = headB->next;
            if (exist.count(headB)) {
                return headB;
            }
        }
        return NULL;
    }
};

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pA = headA, pB = headB;
        HashSet<ListNode> setA = new HashSet<>();
        setA.add(headA);
        while (pA.next != null) {
            pA = pA.next;
            setA.add(pA);
        }
        if (setA.contains(pB)) {
            return pB;
        }
        while (pB.next != null) {
            pB = pB.next;
            if (setA.contains(pB)) {
                return pB;
            }
        }
        return null;
    }
}

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        s = set()
        p, q = headA, headB
        while p:
            s.add(p)
            p = p.next
        while q:
            if q in s:
                return q
            q = q.next
        return None

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> idx;
        for (int i = 0; i < nums.size(); i++) {
            int need = target - nums[i];
            if (idx.count(need)) {
                vector<int> ans{idx[need], i};
                return ans;
            }
            idx[nums[i]] = i;
        }
        return vector<int>(0);
    }
};

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
import java.util.HashMap;
import java.util.Map;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> idx = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int need = target - nums[i];
            if (idx.containsKey(need)) {
                return new int[]{idx.get(need), i};
            }
            idx.put(nums[i], i);
        }
        return new int[0];
    }
}

from typing import List

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        idx = {}
        for i, num in enumerate(nums):
            need = target - num
            if need in idx:
                return [idx[need], i]
            idx[num] = i
        return []