图的深度优先遍历和广度优先遍历

不多说，直接上代码

common.h

#pragma once
#include <iostream>
#include <limits.h>
#include <queue>
#include <utility>
#include <vector>

class Graph
{
   
public:
    int vecnum;
    int edgenum;
    bool *visited;
    std::vector<std::vector<std::pair<int, int>>> vec;
    Graph(const int _vec, const int _edge);
    ~Graph();
    void BFS(int v);
    void DFS(int v);

private:
    void BFSHelper(int u, std::queue<int> &Q);
    void DFSHelper(int u);
    int FirstNeighbor(const int u);
    int NextNeighbor(const int v, const int u);
};

common.cpp

#include "common.h"

Graph::Graph(const int _vec, const int _edge) : vecnum(_vec), edgenum(_edge)
{
   
    visited = new bool[vecnum]{
   false};
    for (int i = 0; i < vecnum; i++)
        vec.push_back({
   });
    int dist, from, to;
    for (int i = 0; i < edgenum; i++)
    {
   
        std::cin >> from >> to >> dist;
        vec[from].push_back({
   to, dist});
        vec[to].push_back({
   from, dist});
    }
    //输出邻接表
    std::cout << std::endl;
    for (int i = 0; i < vecnum; i++)
    {
   
        std::cout << i << ": ";
        for (int j = 0; j < vec[i].size(); j++)
            std::cout << vec[i][j].first << " ";
        std::cout << std::endl;
    }
}
Graph::~Graph()
{
   
    delete[] visited;
    std::cout << "\nObj killed." << std::endl;
}
int Graph::FirstNeighbor(const int u)
{
   
    return !vec[u].size() ? -1 : vec[u][0].first;
}
int Graph::NextNeighbor(const int v, const int u)
{
   
    int loc = 0;
    for (; vec[v][loc].first != u && loc < vec[v].size(); loc++)
        ;

    return loc + 1 < vec[v].size() ? vec[v][loc + 1].first : -1;
}
void Graph::BFSHelper(int u, std::queue<int> &Q)
{
   
    std::cout << u << ' ';
    visited[u] = true;
    Q.push(u);
    while (!Q.empty())
    {
   
        u = Q.front();
        Q.pop();
        for (int i = FirstNeighbor(u); i >= 0; i = NextNeighbor(u, i))
        {
   
            if (!visited[i])
            {
   
                std::cout << i << ' ';
                visited[i] = true;
                Q.push(i);
            }
        }
    }
}
void Graph::BFS(int u)
{
   
    for (int i = 0; i < vecnum; i++)
        visited[i] = false;
    std::queue<int> Q;
    for (int i = u; i < vecnum; i++)
        if (!visited[i])
            BFSHelper(i, Q);
}

void Graph::DFSHelper(int u)
{
   
    std::cout << u << ' ';
    visited[u] = true;
    for (int i = FirstNeighbor(u); i >= 0; i = NextNeighbor(u, i))
        if (!visited[i])
            DFSHelper(i);
}
void Graph::DFS(int u)
{
   
    for (int i = 0; i < vecnum; i++)
        visited[i] = false;
    for (int v = u; v < vecnum; v++)
        if (!visited[v])
            DFSHelper(v);
}

main.cpp

#include "common.h"
int main()
{
   
    int vecnum, edgenum, start;
    std::cout << "Input vecnum: ";
    std::cin >> vecnum;
    std::cout << "Input edgenum: ";
    std::cin >> edgenum;

    Graph G(vecnum, edgenum);

    std::cout << std::endl;
    std::cout << "Where to begin the traverses: ";
    std::cin >> start;

    std::cout << "BFS: ";
    G.BFS(start);
    std::cout << std::endl;

    std::cout << "DFS: ";
    G.DFS(start);
    std::cout << std::endl;

    return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.16.3)
project(GraphTraverse)
add_executable(GraphTraverse main.cpp common.h common.cpp)

几个测试用例

图1

Input vecnum: 8
Input edgenum: 9
0 1 1
0 4 1
0 7 1
1 2 1
1 3 1
2 3 1
4 5 1
4 6 1
2 7 1

0: 1 4 7 
1: 0 2 3 
2: 1 3 7 
3: 1 2 
4: 0 5 6 
5: 4 
6: 4 
7: 0 2 

Where to begin the traverses: 6
BFS: 6 4 0 5 1 7 2 3 
DFS: 6 4 0 1 2 3 7 5 

Obj killed.