使用C++编写一个图的深度和广度优先遍历的代码

//qq460219753获取更多代码
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
// 定义一个图节点结构体
struct GraphNode {
    int val;
    vector<GraphNode*> neighbors;
    GraphNode(int x) : val(x) {};
};
// 深度优先遍历函数
void DFS(GraphNode* node, vector<bool>& visited) {
    // 如果节点已经被访问过，则直接返回
    if (visited[node->val]) {
        return;
    }
    // 输出当前节点的值，并将其标记为已访问
    cout << node->val << " ";
    visited[node->val] = true;
    // 遍历当前节点的所有邻居节点
    for (int i = 0; i < node->neighbors.size(); i++) {
        // 对于每个未访问过的邻居节点，递归调用DFS函数
        if (!visited[node->neighbors[i]->val]) {
            DFS(node->neighbors[i], visited);
        }
    }
}
int main() {
    // 构建一个有向图
    GraphNode* node0 = new GraphNode(0);
    GraphNode* node1 = new GraphNode(1);
    GraphNode* node2 = new GraphNode(2);
    GraphNode* node3 = new GraphNode(3);
    GraphNode* node4 = new GraphNode(4);
    node0->neighbors.push_back(node1);
    node0->neighbors.push_back(node2);
    node1->neighbors.push_back(node2);
    node2->neighbors.push_back(node0);
    node2->neighbors.push_back(node3);
    node3->neighbors.push_back(node3);
    node4->neighbors.push_back(node2);
    node4->neighbors.push_back(node3);
    // 初始化visited数组，所有节点均未被访问过
    vector<bool> visited(5, false);
    // 从节点0开始进行深度优先遍历
    DFS(node0, visited);
    return 0;
}

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>
using namespace std;
// 定义图节点结构体
struct GraphNode {
    int val;  // 节点的值
    vector<GraphNode*> neighbors;  // 节点的邻居
    GraphNode(int x) : val(x) {}
};
// 广度优先遍历函数
void bfs(GraphNode* node) {
    // 定义一个队列来存储遍历到的节点
    queue<GraphNode*> q;
    // 定义一个哈希表来存储已经遍历过的节点
    unordered_set<GraphNode*> visited;
    // 将起始节点加入队列
    q.push(node);
    // 将起始节点标记为已访问
    visited.insert(node);
    // 当队列不为空时，继续遍历
    while (!q.empty()) {
        // 取出队列中的节点
        GraphNode* curr = q.front();
        q.pop();
        // 对当前节点进行操作，这里只是打印节点的值
        cout << curr->val << " ";
        // 遍历当前节点的所有邻居
        for (auto neighbor : curr->neighbors) {
            // 如果邻居节点未被访问过，将其加入队列和已访问哈希表
            if (visited.find(neighbor) == visited.end()) {
                q.push(neighbor);
                visited.insert(neighbor);
            }
        }
    }
}
// 主函数
int main() {
    // 构建一个图
    GraphNode* node0 = new GraphNode(0);
    GraphNode* node1 = new GraphNode(1);
    GraphNode* node2 = new GraphNode(2);
    GraphNode* node3 = new GraphNode(3);
    node0->neighbors = {node1, node2};
    node1->neighbors = {node2, node3};
    node2->neighbors = {node0, node3};
    node3->neighbors = {node3};
    // 对图进行广度优先遍历
    bfs(node0);
    return 0;
}