這個程序是一個圖的實現(xiàn)，使用鄰接表來表示圖的結(jié)構(gòu)：

1. 結(jié)構(gòu)定義部分：
? ?- `AdjListNode` 結(jié)構(gòu)定義了鄰接表中的節(jié)點，每個節(jié)點包含一個名稱和一個指向下一個鄰接節(jié)點的指針。
? ?- `Node` 結(jié)構(gòu)定義了圖中的節(jié)點，每個節(jié)點包含一個名稱和一個指向鄰接表頭部的指針。

鄰接表通常是用鏈表來實現(xiàn)的。在這個程序中，每個節(jié)點（Node）都有一個指向鄰接表頭部的指針（AdjListNode* head），而鄰接表中的每個節(jié)點（AdjListNode）也是鏈表中的一個節(jié)點，通過指針連接起來。

2. 圖類的方法：
? ?- `addNode` 方法用于向圖中添加新的節(jié)點。它創(chuàng)建一個新的 `Node` 對象并將其添加到節(jié)點數(shù)組中。vector<Node> nodes; ?// 存儲圖中所有節(jié)點的數(shù)組
? ?- `addEdge` 方法用于向圖中添加邊。它首先查找源節(jié)點和目標節(jié)點在數(shù)組中的索引，然后創(chuàng)建一個新的鄰接表節(jié)點表示目標節(jié)點，并將其插入到源節(jié)點的鄰接表頭部。
? ?- `printGraph` 方法用于打印圖的鄰接表。它遍歷節(jié)點數(shù)組，對于每個節(jié)點，遍歷其鄰接表并打印節(jié)點名稱。

3. main函數(shù)：
? ?- 在 `main` 函數(shù)中，首先創(chuàng)建了一個 `Graph` 對象。
? ?- 然后通過調(diào)用 `addNode` 方法向圖中添加了幾個節(jié)點。
? ?- 接著通過調(diào)用 `addEdge` 方法向圖中添加了幾條邊。
? ?- 最后調(diào)用 `printGraph` 方法打印了圖的鄰接表。

總體來說，這個程序展示了如何使用 C++ 實現(xiàn)圖的基本操作，包括添加節(jié)點、添加邊和打印鄰接表。

vector<Node> nodes; ?// 存儲圖中所有節(jié)點的數(shù)組
這行代碼聲明了一個名為 nodes 的 vector，用于存儲圖中所有節(jié)點的數(shù)組。
在 C++ 中，vector 是一種動態(tài)數(shù)組，可以自動調(diào)整大小以容納更多的元素。
在這個程序中，nodes 向量存儲的是 Node 結(jié)構(gòu)的對象，即圖中的節(jié)點。
通過 vector 的特性，我們可以方便地添加、刪除和訪問圖中的節(jié)點，而不需要手動管理數(shù)組的大小和內(nèi)存。?

----------

// 這兩行代碼用于將一個新節(jié)點插入到源節(jié)點的鄰接表的頭部。
// 1. `newNode->next = nodes[sourceIndex].head;`:?
// 這行代碼將新節(jié)點的 `next` 指針指向源節(jié)點當前的鄰接表頭部。
// 這確保了新節(jié)點在鏈表中插入的位置是在頭部，而新的頭部后面接著的是原來的鄰接表頭部。
// 簡單來說，這步操作是讓新節(jié)點 "鏈接" 上了原來的鏈表。
// 2. `nodes[sourceIndex].head = newNode;`:?
// 這行代碼將源節(jié)點的鄰接表頭部指針更新為指向新節(jié)點。這步操作是將新節(jié)點設(shè)定為新的鏈表頭部，從而確保鏈表結(jié)構(gòu)的完整性。
// ****綜合來看，這兩行代碼的效果是將一個新節(jié)點插入到源節(jié)點的鄰接表的最前面。
// 在圖的鄰接表表示中，這意味著你在源節(jié)點的連接列表中增加了一個新的鄰接節(jié)點。通過這種方式，可以有效地管理和更新圖的數(shù)據(jù)結(jié)構(gòu)。?

#include <iostream>
#include <string>
#include <vector>using namespace std;// 鄰接表節(jié)點結(jié)構(gòu)
struct AdjListNode {string name;         // 節(jié)點名稱AdjListNode* next;   // 指向下一個鄰接節(jié)點的指針// 構(gòu)造函數(shù)AdjListNode(string name) {this->name = name;   // 初始化節(jié)點名稱this->next = nullptr; // 初始化指針為空}
};// 圖的節(jié)點結(jié)構(gòu)
struct Node {string name;        // 節(jié)點名稱AdjListNode* head;  // 指向鄰接表頭部的指針// 構(gòu)造函數(shù)Node(string name) {this->name = name;   // 初始化節(jié)點名稱this->head = nullptr; // 初始化指針為空}
};// 圖類
class Graph {
private:vector<Node> nodes;  // 存儲圖中所有節(jié)點的數(shù)組public:// 添加節(jié)點到圖中void addNode(string nodeName) {nodes.push_back(Node(nodeName)); // 將新節(jié)點添加到節(jié)點數(shù)組中}// 添加邊到圖中void addEdge(string source, string dest) {int sourceIndex = findNodeIndex(source); // 查找源節(jié)點在數(shù)組中的索引int destIndex = findNodeIndex(dest);     // 查找目標節(jié)點在數(shù)組中的索引if (sourceIndex != -1 && destIndex != -1) { // 如果找到了源節(jié)點和目標節(jié)點AdjListNode* newNode = new AdjListNode(dest); // 創(chuàng)建一個新的鄰接表節(jié)點，表示目標節(jié)點newNode->next = nodes[sourceIndex].head;      // 將新節(jié)點插入到源節(jié)點的鄰接表頭部, 新的頭部后面接著的是原來的鄰接表頭部。nodes[sourceIndex].head = newNode; //將源節(jié)點的鄰接表頭部指針更新為指向新節(jié)點。這步操作是將新節(jié)點設(shè)定為新的鏈表頭部// 這段代碼并沒有處理無向圖的情況，所以會有缺陷// 如果需要處理無向圖，需要額外添加一條邊，指向源節(jié)點// newNode = new AdjListNode(source);// newNode->next = nodes[destIndex].head;// nodes[destIndex].head = newNode;}}// 打印圖的鄰接表void printGraph() {for (const auto& node : nodes) {                   // 遍歷每個節(jié)點cout << node.name << " -> ";                   // 打印節(jié)點名稱AdjListNode* current = node.head;              // 獲取當前節(jié)點的鄰接表頭部while (current) {                              // 遍歷鄰接表cout << current->name;                     // 打印鄰接節(jié)點的名稱if (current->next) cout << " -> ";         // 如果存在下一個節(jié)點，打印箭頭else cout << " -> nullptr";                // 否則打印鏈表末尾current = current->next;                   // 移動到下一個鄰接節(jié)點}if (node.head == nullptr) cout << "nullptr";   // 如果當前節(jié)點沒有鄰接節(jié)點，則輸出 nullptrcout << endl;                                  // 換行}}private:// 查找節(jié)點在數(shù)組中的索引int findNodeIndex(string nodeName) {for (size_t i = 0; i < nodes.size(); ++i) {   // 遍歷節(jié)點數(shù)組if (nodes[i].name == nodeName) {          // 如果找到節(jié)點名稱匹配的節(jié)點return i;                              // 返回節(jié)點在數(shù)組中的索引}}return -1;                                     // 如果沒找到，返回-1}
};int main() {Graph graph;           // 創(chuàng)建圖對象graph.addNode("A");    // 添加節(jié)點graph.addNode("B");graph.addNode("C");graph.addNode("D");graph.addNode("E");graph.addEdge("A", "B"); // 添加邊graph.addEdge("B", "C");graph.addEdge("C", "A");graph.addEdge("C", "D");graph.addEdge("D", "A");graph.printGraph();    // 打印圖的鄰接表return 0;
}// 該程序用于實現(xiàn)一個簡單的圖（Graph）的數(shù)據(jù)結(jié)構(gòu)，圖中包含多個節(jié)點，每個節(jié)點具有一個名稱，并且每個節(jié)點可以與其他節(jié)點相連，以表示圖中邊的關(guān)系。
// 節(jié)點（Node）和鄰接表（AdjListNode）
// Node：每個 Node 對象具有兩個成員變量：一個字符串變量 name，用于保存節(jié)點的名稱，以及一個指針變量 head，用于指向該節(jié)點的鄰接表。
// AdjListNode：每個 AdjListNode 對象具有兩個成員變量：一個字符串變量 name，用于保存鄰接節(jié)點的名稱，以及一個指針變量 next，用于指向下一個鄰接節(jié)點。// 這兩行代碼用于將一個新節(jié)點插入到源節(jié)點的鄰接表的頭部。
// 1. `newNode->next = nodes[sourceIndex].head;`: 
// 這行代碼將新節(jié)點的 `next` 指針指向源節(jié)點當前的鄰接表頭部。
// 這確保了新節(jié)點在鏈表中插入的位置是在頭部，而新的頭部后面接著的是原來的鄰接表頭部。
// 簡單來說，這步操作是讓新節(jié)點 "鏈接" 上了原來的鏈表。
// 2. `nodes[sourceIndex].head = newNode;`: 
// 這行代碼將源節(jié)點的鄰接表頭部指針更新為指向新節(jié)點。這步操作是將新節(jié)點設(shè)定為新的鏈表頭部，從而確保鏈表結(jié)構(gòu)的完整性。
// ****綜合來看，這兩行代碼的效果是將一個新節(jié)點插入到源節(jié)點的鄰接表的最前面。
// 在圖的鄰接表表示中，這意味著你在源節(jié)點的連接列表中增加了一個新的鄰接節(jié)點。通過這種方式，可以有效地管理和更新圖的數(shù)據(jù)結(jié)構(gòu)。// 這兩行代碼一起完成了將新創(chuàng)建的鄰接表節(jié)點插入到源節(jié)點的鄰接表的頭部的操作。讓我解釋一下：
// newNode->next = nodes[sourceIndex].head;：
// 這行代碼將新節(jié)點 newNode 的 next 指針指向了源節(jié)點的鄰接表的頭部。這樣，新節(jié)點就被插入到了鄰接表的頭部位置。
// nodes[sourceIndex].head = newNode;：
// 接著，這行代碼將源節(jié)點的鄰接表的頭指針指向了新節(jié)點 newNode。這樣，新節(jié)點就成為了鄰接表的新的頭部，而原來的鄰接表頭部節(jié)點成為了新節(jié)點的下一個節(jié)點，從而完成了插入操作。// 當你有一個指向?qū)ο蟮闹羔槙r，你可以使用 -> 運算符來訪問該對象的成員，
// 而不必先解引用指針再使用 . 運算符。這在處理動態(tài)分配的對象時特別有用，因為你通常會使用指針來引用它們。// -> 是 C++ 中用于訪問對象成員的運算符，通常用于訪問類的成員或者指向?qū)ο蟮闹羔樀某蓡T。
// 在這個語境中，newNode->next 是指針 newNode 所指向的對象的成員 next。
// 也就是說，newNode->next 表示訪問 newNode 指向的鄰接表節(jié)點的下一個節(jié)點的指針。// -> 符號用于訪問指針的成員。在這里，newNode 是指向 AdjListNode 對象的指針，我們想訪問它的 next 成員。
// -> 符號與 .(->) 等價，但它是一種簡寫方式來訪問指針的成員。
// 因此，newNode->next 等價于 (newNode)->next。它說的是“從 newNode 指向的對象中找出 next 成員”// 什么是 pair ？
// pair 是一個結(jié)構(gòu)體，可以存儲兩個對象的 key-value對。
// 每個 pair 對象包含兩個成員：
// first：一個對象，存儲在 first 中。
// second：另一個對象，存儲在 second 中。
// 為什么使用 pair
// pair 可以用于存儲 key-value對，可以將一個對象與一個哈希表一起使用。
// pair 可以用于存儲多個哈希表中的鍵，可以用于實現(xiàn)哈希表。// vector如何表示其他的容器類型？請詳細列出
// 在C++中，vector是一個能夠存儲任何類型元素的動態(tài)數(shù)組。你可以使用模板來表示不同的容器類型。例如：
// #include <vector>
// #include <list>
// #include <deque>
// #include <set>
// int main() {
//     // 整型向量
//     std::vector<int> intVector;
//     // 字符串向量
//     std::vector<std::string> stringVector;
//     // 列表容器的向量
//     std::vector<std::list<int>> listOfIntsVector;
//     // 雙端隊列容器的向量
//     std::vector<std::deque<double>> dequeOfDoublesVector;
//     // 集合容器的向量
//     std::vector<std::set<std::string>> setOfStringVector;
//     // 你也可以創(chuàng)建自定義類型的向量
//     class MyClass {};
//     std::vector<MyClass> myClassVector;
//     return 0;
// }// // 聲明一個空的 vector 存儲 int 類型
// std::vector<int> v1;
// // 聲明一個帶有初始大小的 vector，所有元素初始化為 0
// std::vector<int> v2(10);  // 10 個元素的 vector，全部初始化為 0
// // 聲明一個帶有初始大小和初始值的 vector
// std::vector<int> v3(5, 42);  // 5 個元素的 vector，全部初始化為 42
// // 通過列表初始化聲明并初始化 vector
// std::vector<int> v4 = {1, 2, 3, 4, 5};  // 直接使用列表初始化
// // 通過拷貝另一個 vector 初始化
// std::vector<int> v5(v4);  // v5 是 v4 的拷貝
// // 從迭代器范圍初始化
// std::vector<int> v6(v4.begin(), v4.begin() + 3);  // 只取 v4 的前 3 個元素
// // 常用操作
// v1.push_back(10);  // 在 vector 尾部添加一個元素
// v1.push_back(20);  // 添加另一個元素// vector 是一個非常靈活和強大的容器，可以存儲基本數(shù)據(jù)類型（如整數(shù)、浮點數(shù)等）和自定義的對象。它支持存儲各種類型的數(shù)據(jù)，包括：
// 在C++中，std::vector是一個序列容器，它可以存儲任何類型的對象，包括基本數(shù)據(jù)類型、標準庫中的容器類型，以及自定義類型。
// 在C++中，可以使用向量（vector）來表示其他容器類型，通過將其他容器類型作為向量的元素來實現(xiàn)。
// 這樣做的好處是可以靈活地存儲和管理不同類型的容器，使得數(shù)據(jù)結(jié)構(gòu)更加動態(tài)和通用。// 基本數(shù)據(jù)類型：如整數(shù)、浮點數(shù)、布爾值等
// 自定義對象：可以創(chuàng)建自定義的對象，并將其存儲在 vector 中
// 其他容器類型：如 std::list、std::deque、std::set 等，可以將這些容器存儲在另一個 vector 中
// vector 的這種靈活性和強大性，讓其成為 C++ 中最廣泛使用的容器之一。// 此外，vector 還提供了許多有用的成員函數(shù)和操作符，例如：
// push_back：將元素添加到 vector 的末尾
// push_front：將元素添加到 vector 的開頭
// insert：將元素插入到 vector 的指定位置
// erase：從 vector 中刪除指定的元素
// resize：將 vector 的大小更改為指定的值
// at：訪問 vector 中指定索引的元素
// operator[]：訪問 vector 中指定索引的元素
// 這些成員函數(shù)和操作符使得 vector 成為了 C++ 中一個非常有用的工具，可以用于各種情況下存儲和操作數(shù)據(jù)。// C++ 中的 vector 是一個非常有用的標準庫容器，用于存儲動態(tài)大小的元素序列。它的功能類似于數(shù)組，但具有更強大的特性和靈活性。
// vector 是一個數(shù)組的容器，可以存儲多個對象。
// 可以存儲任何類型的對象，包括基本類型、對象和結(jié)構(gòu)體。// 特點和優(yōu)勢：
// 動態(tài)大小： vector 的大小可以動態(tài)增長或減小，不像靜態(tài)數(shù)組需要提前定義大小。
// 隨機訪問： 可以使用索引對 vector 中的元素進行快速訪問，時間復(fù)雜度為 O(1)。
// 內(nèi)存管理： vector 會自動處理內(nèi)存的分配和釋放，無需手動管理內(nèi)存。
// 可變操作： 可以在任何位置插入、刪除元素，也可以修改元素的值。
// 迭代器支持： 支持迭代器，可以方便地對 vector 進行遍歷和操作。// 常用方法和操作：
// push_back(element): 在末尾添加元素。
// pop_back(): 移除末尾元素。
// size(): 返回元素個數(shù)。
// empty(): 判斷是否為空。
// clear(): 清空所有元素。
// front(): 返回第一個元素的引用。
// back(): 返回最后一個元素的引用。
// insert(pos, element): 在指定位置插入元素。
// erase(pos): 移除指定位置的元素。
// begin(), end(): 返回迭代器，用于遍歷 vector。
// vector 的靈活性和方便的操作使其成為 C++ 中常用的容器之一，特別適用于需要動態(tài)管理大小的情況。

A -> B -> nullptr
B -> C -> nullptr
C -> D -> A -> nullptr
D -> A -> nullptr
E -> nullptr
請按任意鍵繼續(xù). . .

// 該程序用于實現(xiàn)一個簡單的圖（Graph）的數(shù)據(jù)結(jié)構(gòu)，圖中包含多個節(jié)點，每個節(jié)點具有一個名稱，并且每個節(jié)點可以與其他節(jié)點相連，以表示圖中邊的關(guān)系。
// 節(jié)點（Node）和鄰接表（AdjListNode）
// Node：每個 Node 對象具有兩個成員變量：一個字符串變量 name，用于保存節(jié)點的名稱，以及一個指針變量 head，用于指向該節(jié)點的鄰接表。
// AdjListNode：每個 AdjListNode 對象具有兩個成員變量：一個字符串變量 name，用于保存鄰接節(jié)點的名稱，以及一個指針變量 next，用于指向下一個鄰接節(jié)點。

// 這兩行代碼一起完成了將新創(chuàng)建的鄰接表節(jié)點插入到源節(jié)點的鄰接表的頭部的操作：
// newNode->next = nodes[sourceIndex].head;：
// 這行代碼將新節(jié)點 newNode 的 next 指針指向了源節(jié)點的鄰接表的頭部。這樣，新節(jié)點就被插入到了鄰接表的頭部位置。
// nodes[sourceIndex].head = newNode;：
// 接著，這行代碼將源節(jié)點的鄰接表的頭指針指向了新節(jié)點 newNode。這樣，新節(jié)點就成為了鄰接表的新的頭部，而原來的鄰接表頭部節(jié)點成為了新節(jié)點的下一個節(jié)點，從而完成了插入操作。

---------

// 改進后的代碼主要做了以下幾點改進：

// 引入了 unordered_map 哈希表來存儲節(jié)點，以提高節(jié)點查找效率。
// 使用了智能指針 shared_ptr 來管理節(jié)點和鄰接表節(jié)點的內(nèi)存，避免了手動內(nèi)存管理和可能的內(nèi)存泄漏問題。
// 對節(jié)點和邊的添加操作進行了有效性檢查，防止添加不存在的節(jié)點之間的邊。
// 使用了范圍-based for 循環(huán)來遍歷節(jié)點哈希表，代碼更加簡潔。
// 增加了注釋以說明代碼的作用和改進部分。

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map> // 引入哈希表
#include <memory>        // 引入智能指針using namespace std;// 鄰接表節(jié)點結(jié)構(gòu)
struct AdjListNode {string name;             // 節(jié)點名稱shared_ptr<AdjListNode> next;  // 指向下一個鄰接節(jié)點的智能指針// 構(gòu)造函數(shù)AdjListNode(string name) : name(name), next(nullptr) {}
};// 圖的節(jié)點結(jié)構(gòu)
struct Node {string name;              // 節(jié)點名稱shared_ptr<AdjListNode> head;  // 指向鄰接表頭部的智能指針// 構(gòu)造函數(shù)Node(string name) : name(name), head(nullptr) {}
};// 圖類
class Graph {
private:unordered_map<string, shared_ptr<Node>> nodes; // 使用哈希表存儲節(jié)點，提高節(jié)點查找效率public:// 添加節(jié)點到圖中void addNode(const string& nodeName) {// 檢查節(jié)點是否已存在if (nodes.find(nodeName) == nodes.end()) {nodes[nodeName] = make_shared<Node>(nodeName); // 使用智能指針管理節(jié)點}}// 添加邊到圖中void addEdge(const string& source, const string& dest) {// 檢查源節(jié)點和目標節(jié)點是否存在if (nodes.find(source) != nodes.end() && nodes.find(dest) != nodes.end()) {// 創(chuàng)建新的鄰接表節(jié)點，表示目標節(jié)點shared_ptr<AdjListNode> newNode = make_shared<AdjListNode>(dest);//  這行代碼的作用是將新節(jié)點的 next 指針指向源節(jié)點的鄰接表的頭部節(jié)點，即將新節(jié)點插入到鄰接表的頭部。// 代碼的目的是將新節(jié)點 newNode 的 next 指針指向了原來的鏈表頭部節(jié)點（如果存在的話），以便在將新節(jié)點插入到鏈表頭部后，新節(jié)點的下一個節(jié)點是原來的鏈表頭部節(jié)點。newNode->next = nodes[source]->head; // 將新節(jié)點插入到源節(jié)點的-鄰接表頭部nodes[source]->head = newNode;// 如果要支持無向圖，還需添加下面這段代碼// newNode = make_shared<AdjListNode>(source);// newNode->next = nodes[dest]->head;// nodes[dest]->head = newNode;}}// 打印圖的鄰接表void printGraph() {for (const auto& pair : nodes) {                     // 遍歷節(jié)點哈希表cout << pair.first << " -> ";                     // 打印節(jié)點名稱shared_ptr<AdjListNode> current = pair.second->head; // 獲取當前節(jié)點的鄰接表頭部while (current) {                                // 遍歷鄰接表cout << current->name;                       // 打印鄰接節(jié)點的名稱if (current->next) cout << " -> ";           // 如果存在下一個節(jié)點，打印箭頭else cout << " -> nullptr";                  // 否則打印鏈表末尾current = current->next;                     // 移動到下一個鄰接節(jié)點}if (!pair.second->head) cout << "nullptr";       // 如果當前節(jié)點沒有鄰接節(jié)點，則輸出 nullptrcout << endl;                                    // 換行}}
};int main() {Graph graph;           // 創(chuàng)建圖對象graph.addNode("A");    // 添加節(jié)點graph.addNode("B");graph.addNode("C");graph.addNode("D");graph.addNode("E");graph.addEdge("A", "B"); // 添加邊graph.addEdge("B", "C");graph.addEdge("C", "A");graph.addEdge("C", "D");graph.addEdge("D", "A");graph.printGraph();    // 打印圖的鄰接表return 0;
}
// 改進后的代碼主要做了以下幾點改進：// 引入了 unordered_map 哈希表來存儲節(jié)點，以提高節(jié)點查找效率。
// 使用了智能指針 shared_ptr 來管理節(jié)點和鄰接表節(jié)點的內(nèi)存，避免了手動內(nèi)存管理和可能的內(nèi)存泄漏問題。
// 對節(jié)點和邊的添加操作進行了有效性檢查，防止添加不存在的節(jié)點之間的邊。
// 使用了范圍-based for 循環(huán)來遍歷節(jié)點哈希表，代碼更加簡潔。
// 增加了注釋以說明代碼的作用和改進部分。// 原有的鏈表頭部節(jié)點并沒有丟失或刪除，而是被重新連接到了新插入的節(jié)點后面。讓我用更詳細的方式解釋一下：
// 假設(shè)我們有一個鏈表，頭部節(jié)點是 A，它的下一個節(jié)點是 B，而我們要在 A 的前面插入一個新節(jié)點 X。
// 初始狀態(tài)：
// A -> B
// 現(xiàn)在我們要在 A 的前面插入 X：
// 我們先將 X 的 next 指針指向原來 A 的下一個節(jié)點 B：
// X -> B
// 然后我們將 A 的 next 指針指向 X：
// A -> X -> B
// 這樣，我們成功地在鏈表的頭部插入了新的節(jié)點 X，同時保留了原來的節(jié)點順序。
// 原來的頭部節(jié)點 A 現(xiàn)在變成了新節(jié)點 X 的下一個節(jié)點，它沒有被丟失或刪除，只是它的位置改變了。// 理解指針的操作可以有一些技巧，特別是在涉及鏈表這樣的數(shù)據(jù)結(jié)構(gòu)時。讓我嘗試用更詳細的步驟來解釋這段代碼中指針的操作過程。
// 假設(shè)我們有一個圖的鄰接表，每個節(jié)點 `nodes[i]` 都包含一個指向鏈表頭部的指針 `head`，其中鏈表的每個節(jié)點表示一個與節(jié)點 `i` 相鄰的節(jié)點。
// 現(xiàn)在來看看這段代碼的每一步：
// 1. **新建節(jié)點 `newNode`**：
//    shared_ptr<AdjListNode> newNode = make_shared<AdjListNode>(destination);
//    這行代碼創(chuàng)建了一個新的節(jié)點 `newNode`，并將目標節(jié)點 `destination` 作為其參數(shù)。
// 2. **將新節(jié)點插入到鄰接表的頭部**：
//    newNode->next = nodes[source]->head;
//    nodes[source]->head = newNode;
//    - `nodes[source]->head` 表示源節(jié)點 `source` 的鄰接表的頭部指針。初始時，這個指針可能是 `nullptr`，即該節(jié)點的鄰接表為空。
//    - `newNode->next = nodes[source]->head;` 這行代碼將新節(jié)點 `newNode` 的 `next` 指針指向了源節(jié)點 `source` 的鄰接表的頭部節(jié)點。
//    這意味著新節(jié)點 `newNode` 現(xiàn)在指向原先作為頭部的節(jié)點（如果存在的話，否則指向 `nullptr`）。
//    - `nodes[source]->head = newNode;` 這行代碼將源節(jié)點 `source` 的鄰接表的頭部指針 `head` 指向了新插入的節(jié)點 `newNode`。
//    現(xiàn)在，新節(jié)點 `newNode` 成為了鄰接表的頭部節(jié)點，而原來的頭部節(jié)點（如果存在的話）則成為了新節(jié)點 `newNode` 的下一個節(jié)點。
// 所以，這段代碼的目的是將新節(jié)點 `newNode` 插入到源節(jié)點 `source` 的鄰接表的頭部位置，以構(gòu)建源節(jié)點 `source` 的鄰接表鏈表。
// 這種操作是在圖的鄰接表表示中常見的方式，用于將新的鄰接節(jié)點添加到某個節(jié)點的鄰接表中。