NotesOnSets.cpp

Perfect! Let’s review **sets vs. sequences** and **set relationships** in the context of **C++**, with examples and which STL (Standard Template Library) containers you'd use.

---

## 🔹 **Set vs. Sequence in C++**

### ✅ Sets in C++
- **Unordered, no duplicates**
- Use when you care about **uniqueness** and **fast lookup**

```cpp
#include <set>
#include <unordered_set>

std::set<int> orderedSet = {3, 1, 4};              // auto-sorted: 1, 3, 4
std::unordered_set<int> fastSet = {3, 1, 4};       // no guaranteed order

orderedSet.insert(2);     // Now: 1, 2, 3, 4
fastSet.count(3);         // Fast check if 3 exists
```

### ✅ Sequences in C++
- **Ordered, allows duplicates**
- Use when **order matters** or you need **indexed access**

```cpp
#include <vector>
#include <list>
#include <deque>

std::vector<int> numbers = {1, 2, 2, 3};     // Duplicates allowed
numbers.push_back(4);                       // Adds 4 to the end
int x = numbers[0];                         // Access via index

std::list<int> linked = {1, 2, 3};          // Doubly linked list
```

---

## 🔹 **Set Relationships in C++**

### 1️⃣ One-to-One (Injective)
Use `std::map` to store unique keys and unique values.

```cpp
#include <map>
std::map<int, std::string> studentToID;  // studentID -> schoolEmail

studentToID[1001] = "alice@school.edu";
studentToID[1002] = "bob@school.edu";
```

- Each key maps to exactly one unique value
- Values *should* be unique too, but C++ `map` doesn’t enforce it

---

### 2️⃣ One-to-Many
Use `std::map<int, std::vector<std::string>>`

```cpp
std::map<int, std::vector<std::string>> teacherToStudents;

teacherToStudents[101].push_back("Alice");
teacherToStudents[101].push_back("Bob");
```

- One teacher ID maps to **multiple students**
- Values stored as vectors or sets

---

### 3️⃣ Many-to-One
Use `std::unordered_map<std::string, int>`

```cpp
std::unordered_map<std::string, int> studentToCounselor;

studentToCounselor["Alice"] = 501;
studentToCounselor["Bob"] = 501;   // Same counselor ID
```

- Multiple keys map to the same value

---

### 4️⃣ Many-to-Many
Use `std::unordered_map<std::string, std::unordered_set<std::string>>`

```cpp
std::unordered_map<std::string, std::unordered_set<std::string>> studentToClubs;

studentToClubs["Alice"].insert("Chess Club");
studentToClubs["Alice"].insert("Drama Club");
studentToClubs["Bob"].insert("Drama Club");
```

- Each student joins multiple clubs
- Each club can have multiple students (you’d create another map for club → students)

---

## 🔁 Summary Table (C++)

| Relationship Type | STL Container(s) |
|-------------------|------------------|
| Set               | `std::set`, `std::unordered_set` |
| Sequence          | `std::vector`, `std::list`, `std::deque` |
| One-to-One        | `std::map`       |
| One-to-Many       | `std::map<Key, std::vector<Value>>` |
| Many-to-One       | `std::unordered_map<Value, Key>` |
| Many-to-Many      | `std::unordered_map<Key, std::unordered_set<Value>>` |

---

Want to go over how to write a class to manage any of these mappings, or how this ties into Discrete Math concepts like injective/surjective functions?