数据结构与算法(C++) -- 图的DFS 和 BFS based on adjMat queue-BFS stack-DFS

最新推荐文章于 2022-10-26 10:46:05 发布
最新推荐文章于 2022-10-26 10:46:05 发布
阅读量252 收藏
点赞数
分类专栏： 数据结构与算法基础（c++实现）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33963083/article/details/100125989
版权

文章目录

0. 概览

在这里插入图片描述

1. DFS

在这里插入图片描述
先从A->B->E->C，再返回C->E->B->A->D，但是要跳过搜索过的顶点，最后输出A->B->E->C->D。
在这里插入图片描述

#include <iostream>
#include <stack>
using namespace std;

// 深度优先搜索算法
// 沿着顶点一直找,找到最后一个顶点,然后返回横向找, 不包括已经搜索过的点
// 使用堆栈更合适, 往回找时 先进后出FILO 后进先出LIFO
// 用邻接矩阵和stack 

#define MAXVERTEX_NUMS 20
class Graph;
class Vertex
{
    friend class Graph;
public:
    Vertex(const char dt): data(dt) { }
private:
    char data;
};
class Graph
{
public:
    Graph()
    : nVertex(0), vertexTable(new Vertex*[MAXVERTEX_NUMS]) // 初始化当前顶点个数 和 存放顶点的数组
    {
        for(int i=0; i<MAXVERTEX_NUMS; i++) // 初始化顶点状态
            visitedV[i] = 0; 

        for(int i=0; i<MAXVERTEX_NUMS; i++) // 初始化adjacency matrix
            for(int j=0; j<MAXVERTEX_NUMS; j++)
                adjMat[i][j] = 0;
    }
    ~Graph() { delete[] vertexTable; } // vertexTable中存放的不是new出来的Vertex, 所以只需delete数组即可
    void addVertex(Vertex& v);
    void addEdge(const Vertex& v1, const Vertex& v2);
    void printVertex() const;
    void printAdjMat() const; 
    void printDFS(); // ***********8重点是printDFS()****************
private:
    Vertex** vertexTable;                        // 存放顶点 
    bool visitedV[MAXVERTEX_NUMS];               // 存放顶点是否被遍历的状态
    bool adjMat[MAXVERTEX_NUMS][MAXVERTEX_NUMS]; // adjacency matrix
    int nVertex;                                 // 当前顶点个数 
};
void Graph::addVertex(Vertex& v)
{
    vertexTable[nVertex++] = &v;
}
void Graph::addEdge(const Vertex& v1, const Vertex& v2)
{
    adjMat[v1.data-65][v2.data-65] = 1;
    adjMat[v2.data-65][v1.data-65] = 1;
}
void Graph::printVertex() const
{
    for(int i=0; i<nVertex; i++)
        cout << vertexTable[i]->data << " ";
    cout << endl;
}
void Graph::printAdjMat() const
{
    for(int i=0; i<nVertex; i++)
    {    
        for(int j=0; j<nVertex; j++)
            cout << adjMat[i][j] << " ";
        cout << endl;
    }
}
// ----------------------------DFS---------------------------------------
void Graph::printDFS()
{
    auto vnextUnvisited = [&](const Vertex* v)->int // 返回顶点在vertexTable中的位置
    {
        for(int i=0; i<nVertex; i++)                  // 搜索adjacency matrix的每一行
            if(adjMat[v->data-65][i] && !visitedV[i]) // 如果给定顶点,在邻接表找到1 且 没被访问过
                return vertexTable[i]->data - 65;     // 返回该顶点对应表中的位置
        return -1; // 如果没找到返回-1
    };

    stack<Vertex*> gStack;  // 用stack存放 遍历过的 顶点 
    int i = 0;              // 记录顶点在vertexTable中的索引
    visitedV[i] = true;                  // 标记第一个顶点已被访问
    cout << vertexTable[i]->data << " "; // 输出
    gStack.push(vertexTable[i]);         // 压入起点
    while(!gStack.empty())
    {
        i = vnextUnvisited(gStack.top()); // 访问第下个顶点
        if(i >= 0) // 存在
        {
            visitedV[i] = true;                  // 标记被访问
            cout << vertexTable[i]->data << " "; // 输出
            gStack.push(vertexTable[i]);         // 压入
        }
        else // 没有下个顶点了
        {
            gStack.pop();
        }
    }
    cout << endl;
    for(int j=0; j<nVertex; j++) // 状态表置零  可以多次搜索
        visitedV[j] = false;
}
// -----------------------------------------------------------------------


int main()
{
    Vertex vA('A');    // 创建顶点
    Vertex vB('B');
    Vertex vC('C');
    Vertex vD('D');
    Vertex vE('E');

    Graph G;           // 创建图 
    G.addVertex(vA);   // 添加顶点
    G.addVertex(vB);
    G.addVertex(vC);
    G.addVertex(vD);
    G.addVertex(vE);
    G.addEdge(vA, vB); // 添加边
    G.addEdge(vA, vD);
    G.addEdge(vB, vE);
    G.addEdge(vD, vE);
    G.addEdge(vC, vE);

    G.printVertex();  // 打印顶点
    G.printAdjMat();  // 打印邻接矩阵

    cout << "=============\n";
    G.printDFS();     // 打印深度优先搜索结果
// output:
    // A B C D E 
    // 0 1 0 1 0 
    // 1 0 0 0 1 
    // 0 0 0 0 1 
    // 1 0 0 0 1 
    // 0 1 1 1 0 
    // =============
    // A B E C D 

    return 0;
}

2.BFS

在这里插入图片描述
先从A开始，一层一层的搜索，A->B->D->E->C。
在这里插入图片描述

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

// 广(宽)度优先搜索算法 Breadth First Search
// 顶点周围找,找完继续找下一个顶点的周围
// 先把第一个顶点周围的 顶点放入队列, 然后依次取出顶点,继续放入周围的队列 (一层一层的搜索)
// 使用队列,,  先放入的顶点先搜索周围其他顶点, 先进先出FIFO

#define MAXVERTEX_NUMS 20
class Graph;
class Vertex
{
    friend class Graph;
public:
    Vertex(const char dt): data(dt) { }
private:
    char data;
};
class Graph
{
public:
    Graph()
    : nVertex(0), vertexTable(new Vertex*[MAXVERTEX_NUMS]) // 初始化当前顶点个数 和 存放顶点的数组
    {
        for(int i=0; i<MAXVERTEX_NUMS; i++) // 初始化顶点状态
            visitedVtable[i] = 0; 

        for(int i=0; i<MAXVERTEX_NUMS; i++) // 初始化adjacency matrix
            for(int j=0; j<MAXVERTEX_NUMS; j++)
                adjMat[i][j] = 0;
    }
    ~Graph() { delete[] vertexTable; } // vertexTable中存放的不是new出来的Vertex, 所以只需delete数组即可
    void addVertex(Vertex& v);
    void addEdge(const Vertex& v1, const Vertex& v2);
    void printVertex() const;
    void printAdjMat() const; 
    void printDFS(); // ***********重点是printDFS()****************
    void printBFS(); // ***********重点是printBFS()****************
private:
    Vertex** vertexTable;                        // 存放顶点 
    bool visitedVtable[MAXVERTEX_NUMS];          // 存放顶点是否被遍历的状态
    bool adjMat[MAXVERTEX_NUMS][MAXVERTEX_NUMS]; // adjacency matrix
    int nVertex;                                 // 当前顶点个数 
};
void Graph::addVertex(Vertex& v)
{
    vertexTable[nVertex++] = &v;
}
void Graph::addEdge(const Vertex& v1, const Vertex& v2)
{
    adjMat[v1.data-65][v2.data-65] = 1;
    adjMat[v2.data-65][v1.data-65] = 1;
}
void Graph::printVertex() const
{
    for(int i=0; i<nVertex; i++)
        cout << vertexTable[i]->data << " ";
    cout << endl;
}
void Graph::printAdjMat() const
{
    for(int i=0; i<nVertex; i++)
    {    
        for(int j=0; j<nVertex; j++)
            cout << adjMat[i][j] << " ";
        cout << endl;
    }
}
// ----------------------------DFS---------------------------------------
void Graph::printDFS()
{
    auto vnextUnvisited = [&](const Vertex* v)->int // 返回顶点在vertexTable中的位置
    {
        for(int i=0; i<nVertex; i++)                       // 搜索adjacency matrix的每一行
            if(adjMat[v->data-65][i] && !visitedVtable[i]) // 如果给定顶点,在邻接表找到1 且 没被访问过
                return i;                                  // 返回该顶点对应表中的位置
        return -1; // 如果没找到返回-1
    };

    stack<Vertex*> gStack;  // 用stack存放 遍历过的 顶点 
    int i = 0;              // 记录顶点在vertexTable中的索引
    visitedVtable[i] = true;             // 标记第一个顶点已被访问
    cout << vertexTable[i]->data << " "; // 输出
    gStack.push(vertexTable[i]);         // 压入起点
    while(!gStack.empty())
    {
        i = vnextUnvisited(gStack.top()); // 访问第下个顶点
        if(i >= 0) // 存在
        {
            visitedVtable[i] = true;             // 标记被访问
            cout << vertexTable[i]->data << " "; // 输出
            gStack.push(vertexTable[i]);         // 访问过的顶点 都要压入stack
        }
        else // 没有下个顶点了
        {
            gStack.pop();
        }
    }
    cout << endl;
    for(int j=0; j<nVertex; j++) // 状态表置零  可以多次搜索
        visitedVtable[j] = false;
}
// -----------------------------------------------------------------------

// ----------------------------BFS----------------------------------------
void Graph::printBFS()
{
    auto vnextUnvisited = [&](Vertex* v) -> int
    {
        for(int i=0; i<nVertex; i++)
        {
            if(adjMat[v->data - 65][i] && !visitedVtable[i])
                return i;
            return -1;
        }   
    };

    queue<Vertex*> gQueue;       // 用于保存顶点
    int i = 0;                   // 用于保存当前顶点的索引
    visitedVtable[i] = true;     // 标记该顶点已被遍历
    gQueue.push(vertexTable[i]); // 存入queue
    while(!gQueue.empty()) // 遍历 queue里保存的 顶点
    {
        i = gQueue.front()->data - 65;          // 从queue中取出一个顶点,获取索引号
        int j = vnextUnvisited(gQueue.front()); // 记录 当前顶点下一个连接顶点 的起始位置, 记录adjMat的一行索引, 从第一个连接顶点开始                  // 
        while(j < nVertex) // 遍历完周围没有被 遍历过的 顶点
        {
            if(adjMat[i][j] && !visitedVtable[j]) // j对应的这个周围顶点 没有被遍历过的
            {
                visitedVtable[j] = true;          // 标记该顶点已被遍历
                gQueue.push(vertexTable[j]);      // 存入queue
            }
            j++;                                  // 寻找下一个 周围的顶点
        }
        cout << gQueue.front()->data << " "; // 当前顶点周围顶点都存进queue时, 输出当前节点
        gQueue.pop();                        // 并删除这个顶点,指向下一个
    }

    cout << endl;
    for(int ii=0; ii<nVertex; ii++) // 为方便多次搜索, 需要清零 是否被搜索过的记录
        visitedVtable[ii] = false;
}
// -----------------------------------------------------------------------


int main()
{
    Vertex vA('A');    // 创建顶点
    Vertex vB('B');
    Vertex vC('C');
    Vertex vD('D');
    Vertex vE('E');

    Graph G;           // 创建图 
    G.addVertex(vA);   // 添加顶点
    G.addVertex(vB);
    G.addVertex(vC);
    G.addVertex(vD);
    G.addVertex(vE);
    G.addEdge(vA, vB); // 添加边
    G.addEdge(vA, vD);
    G.addEdge(vB, vE);
    G.addEdge(vD, vE);
    G.addEdge(vC, vE);

    G.printVertex();  // 打印顶点
    G.printAdjMat();  // 打印邻接矩阵

    cout << "=============\n";
    G.printDFS();     // 打印深度优先搜索结果 DFS
    G.printBFS();     // 打印广度优先搜索结果 BFS
// output:
    // A B C D E 
    // 0 1 0 1 0 
    // 1 0 0 0 1 
    // 0 0 0 0 1 
    // 1 0 0 0 1 
    // 0 1 1 1 0 
    // =============
    // A B E C D 
    // A B D E C 

    return 0;
}

测试二，plus代码

在这里插入图片描述

// 邻接矩阵如下
    // 0 0 1 1 0 1 0
    // 0 0 1 0 0 0 0
    // 1 1 0 1 0 0 0 
    // 1 0 1 0 0 0 0
    // 0 0 0 0 0 0 1
    // 1 0 0 0 0 0 1
    
// DFS: A C B D F G E 
// BFS: A C D F B G E

#include<iostream>
#include <cstring>
#include<stack>
#include<queue>

using namespace std;

#define MAX_SIZE    (10)

template<typename T>
class Vertex
{
public:
    Vertex(const char n, const T& d=T())
    : name(n), data(d) { }
    char name;
    T data;
};

template<typename T>
class Graph
{
public:
    Graph()
    {
        theSize = 0;
        for (int i=0; i<MAX_SIZE; ++i) 
            for (int j=0; j<MAX_SIZE; ++j) 
                adjMat[i][j] = 0;
    }
    // 递归 或者 stack
    void DFS()
    {
        if (theSize == 0) return;

        bool visited[theSize];      // 记录被访问过的顶点
        memset(visited, 0, theSize);// 初始置0
        
        stack<Vertex<T>*> vStack;       // DFS栈
        int index = 0;                  // 记录没有访问过的顶点的索引
        Vertex<T>* first = vertexTable[index];
        cout << first->name << " ";     // visited
        visited[index] = true;          // 标记被访问           
        vStack.push(vertexTable[index]);// 第一个入栈
        while (!vStack.empty()) {
            auto p = vStack.top();      // 获取栈顶
            // 查找p点周围没有被访问过的点
            for (int i=0; i<theSize; ++i) {
                if (!visited[i] && adjMat[p->name - 'A'][i]) {
                    index = i;
                    break;
                } else index = -1;
            }
            // 该顶点周围的点都被访问过了
            if (index == -1) {
                vStack.pop();
            }
            // p周围还存在没被访问过的顶点，访问，入栈
            else {
                cout << vertexTable[index]->name << " ";
                visited[index] = true;  // 标记被访问           
                vStack.push(vertexTable[index]);
            }
        }
        cout << endl;
    }
    // queue 入q就标记被访问, pop只打印
    void BFS()
    {
        bool visited[theSize];
        memset(visited, 0, sizeof(visited));

        queue<Vertex<T>*> vQueue;
        vQueue.push(vertexTable[0]);        // 从第一个顶点开始
        visited[0] = true;                  // 标记

        while (!vQueue.empty()) {
            Vertex<T>* p = vQueue.front();  // 取出队头
            vQueue.pop();
            cout << p->name << " ";         // 打印
            // 周围的点都入queue, 没有被访问过且有连接关系
            for (int i=0; i<theSize; ++i) {
                if (!visited[i] && adjMat[p->name - 'A'][i]) {
                    vQueue.push(vertexTable[i]);                // 入queue
                    visited[vertexTable[i]->name - 'A'] = true; // 标记
                }
            }
        }
    }
    void add_vertex(Vertex<T>& v) { vertexTable[theSize++] = &v; }
    void add_edge(const Vertex<T>& v1, const Vertex<T>& v2) 
    {
        adjMat[v1.name - 'A'][v2.name - 'A'] = 1;   // 对称阵
        adjMat[v2.name - 'A'][v1.name - 'A'] = 1;   // 对称阵
    }
    void print_adjmat() const 
    { 
        for (int i=0; i<theSize; ++i) {
            for (int j=0; j<theSize; ++j) 
                cout << adjMat[i][j] << " ";
            cout << endl;
        }
    }
private:
    Vertex<T>* vertexTable[MAX_SIZE];
    bool adjMat[MAX_SIZE][MAX_SIZE];
    int theSize;
};


int main()
{
    Graph<string> gh;
    Vertex<string> vA('A');
    Vertex<string> vB('B');
    Vertex<string> vC('C');
    Vertex<string> vD('D');
    Vertex<string> vE('E');
    Vertex<string> vF('F');
    Vertex<string> vG('G');

    gh.add_vertex(vA);
    gh.add_vertex(vB);
    gh.add_vertex(vC);
    gh.add_vertex(vD);
    gh.add_vertex(vE);
    gh.add_vertex(vF);
    gh.add_vertex(vG);
    gh.print_adjmat(); cout << endl;

    gh.add_edge(vA, vC);
    gh.add_edge(vA, vD);
    gh.add_edge(vA, vF);
    gh.add_edge(vB, vC);
    gh.add_edge(vC, vD);
    gh.add_edge(vE, vG);
    gh.add_edge(vF, vG);
    gh.print_adjmat();

    gh.DFS();
    gh.BFS();

// stdout
    // 0 0 1 1 0 1 0
    // 0 0 1 0 0 0 0
    // 1 1 0 1 0 0 0 
    // 1 0 1 0 0 0 0
    // 0 0 0 0 0 0 1
    // 1 0 0 0 0 0 1
    // DFS: A C B D F G E 
    // BFS: A C D F B G E

    return 0;
}
巴德鸟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++用stack实现深度优先搜索DFS(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-15 820
C++用stack实现深度优先搜索DFS的实现C++用stack实现深度优先搜索DFS的完整源码（定义，实现，main函数测试） C++用stack实现深度优先搜索DFS的完整源码（定义，实现，main函数测试） #include <iostream> /// for IO operations #include <stack> /// header for std::stack #include <vector> /// header for st
dfs_bfs.rar_C-C++_bfs
09-23
标题中的“dfs_bfs.rar”指的是一个压缩文件，其中包含了关于深度优先搜索（DFS, Depth First Search）和广度优先搜索（BFS, Breadth First Search）的C++程序。这两种算法是图论和计算机科学中常用的数据结构遍历...
通过c++ 实现dfs算法
leduoduodeai的博客
10-26 1958
深度优先搜索算法(以下简称DFS)是一种用于遍历（或搜索）树（或图）的算法。我们构造这样一个图（如下图），并通过C++实现DFS 算法过程1.从根节点开始2.放入一个节点（起始时放入的为根节点）3.如果这个节点是第一次出现，则放入堆栈中4.判断该节点的子节点是否搜索完成， a.如果是则将该节点出栈,判断该栈是否为空 a.1 若为空则结束 a.2 若不为空则取栈顶元素，并回到第2步 b.如果没有完成搜索，取未被搜索的根节点，并回到第2步
数据结构&算法-----（5）图、DFS与BFS、Dijstra
王胖泽的博客
03-05 435
LeetCode温习-----（5）深度与广度优先搜索深度优先搜索（Depth-First Search / DFS） 深度优先搜索（Depth-First Search / DFS） 深度优先搜索，从起点出发，从规定的方向中选择其中一个不断地向前走，直到无法继续为止，然后尝试另外一种方向，直到最后走到终点。就像走迷宫一样，尽量往深处走。 DFS 解决的是连通性的问题，即，给定两个点，一个是起始点...
深度优先搜索（DFS）C++
阿怪的博客
10-12 497
深度优先搜索（DFS） 深度优先搜索是搜索的手段之一。它是从某个状态开始，不断转移状态，直到无法转移，然后退回到前一步的状态，继续转移到其他状态，如此不断重复，直至找到最终解。 深度优先搜索（隐式的）利用了栈进行计算，栈（Stack）支持push和pop两种操作，数据元素先进先出。 例题：Lake Counting (POJ No.2386) 题目描述 有一个大小为N * M 的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出园子里总共有多少水洼？（八连通指的是下图中相对 W 的 * 的部分）
c++之图的深度优先遍历（DFS)
weixin_42579072的博客
11-07 2001
因为图一般存储结构有两种： 邻接矩阵 邻接表 本文基于邻接矩阵实现图的深度优先遍历 #include <iostream> #include<vector> using namespace std; int book[101], sum, n, e[101][101]; vector<char> vec; void dfs(int cur) { int ...
ACM算法设计-BFS-DFS详解_算法_dfs_ACM_zoouts_bfs_
10-01
在计算机科学领域，特别是算法设计中，BFS（广度优先遍历）和DFS（深度优先遍历）是两种常用图或树结构的遍历方法。这两种算法在解决许多问题时发挥着至关重要的作用，例如在寻找最短路径、解决迷宫问题、网络爬虫...
The-Search-in-Pac-Man:使用BFS DFS UCS Astar在吃豆人中搜索
05-14
在search.py的depthFirstSearch函数中实现了深度优先搜索（DFS）算法。 python pacman.py -l tinyMaze -p SearchAgent python pacman.py -l mediumMaze -p SearchAgent python pacman.py -l bigMaze -z ...
C++-VS2019-迷宫寻路BFS+DFS代码.zip
07-22
最终效果是实现了Prim随机生成迷宫，BFS&DFS路径显示、最短路长度显示、过程动态展示，主函数中有菜单，操作方便。 不仅可以用来读代码长知识、还可以用作算法演示。 附带第五版的exe文件，欢迎使用！
数据结构-DFS and BFS-PPT
最新发布
02-04
"数据结构-DFS和BFS-PPT" 数据结构是计算机科学中的一种基本概念，它是指数据在计算机中的组织和存储方式。DFS（Depth-First Search，深度优先搜索）和BFS（Breadth-First Search，广度优先搜索）是两种常用的图...
贪婪算法——Prim 算法
zmeilin的博客
07-24 740
在实践中常常会遇到这样的问题：给定n人点，把它们按照一种代价最低的方式连接起来，使得任意两点之间都存在一条路径。 这样的问题可应用在各类网络的设计，包括通信网络、计算机网络、交通网络以及输电网络，从而能够以最低的成本实现网络联通。另外，它也有助于构造旅行商等难题的近似解。   定义：通图的一棵生成树是包含图中的所有顶点的连通无环子图（也就是一棵树）。加权连通图的一棵最小生成树是图的一棵权重最...
一文带你了解dfs和bfs算法
热门推荐
Twinkle_sone的博客
01-21 1万+
一文带你了解dfs和bfs算法 如上图，dfs和bfs算法通常会用来解决迷宫问题，两种算法都可以找到一条通往重点的路，但又有不一样的地方。 体验地址：http://120.79.163.94/demo/寻路算法.html 可以自己定义迷宫是否可走，及起始点和终点。 深度优先算法（dfs） 简介 dfs算法又称深度优先搜索，是计算机术语。 1、dfs是一种在开发爬虫早期使用较多的方法，是搜索算法的一种。 2、dfs的目的是要达到被搜索结构的叶结点，即那些不包含任何超链的HTML文件。 3、dfs根据已有的邻
图卷积网络在推荐系统中的应用NGCF（Neural Graph Collaborative Filtering）配套pytorch的代码解释
zhao254014的博客
04-06 7275
NGCF论文详解加代码详细注释，图卷积网络在推荐系统中的应用，
图论：BFS算法与DFS算法的C++实现
m0_57298222的博客
03-12 2790
关于算法的准确性，本人只测试了比较简单的情况，两个算法是否存在未发现的漏洞，本人不做任何担保 BFS算法： 类似于树的层序遍历，需要借助队列实现` 算法的基本流程：起始点——探索未遍历的邻接点——未遍历的邻接点作为新的起始点重复` #include <iostream> #include <vector> #include <queue> #include "adjacency_list.h" using namespace std; //构建邻接表 struct adj
用队列实现bfs & 用栈实现dfs & 用dfs实现bfs
weixin_44284194的博客
04-12 849
样例输入 3 6 2 2 2 3 4 1 样例输出 9 思路： 典型的bfs问题，这里尝试用bfs和dfs两种方法解，旨在练习两者实现方式和对比 样例说明 　　用1表示灌溉到，0表示未灌溉到。 　　打开水管时： 　　000000 　　010000 　　000100 　　1分钟后： 　　010000 　　111100 　　011110 　　共有9个方格被灌溉好。 数据规模和约定 　　对于所有评测用例，1 <= n, m <= 100, 1 <= t <= 10, 1 <= .
图遍历(DFS, BFS) python实现
Lucas66666的博客
12-15 1476
一 摘要 图遍历方法包括深度遍历(DFS)和广度遍历(BFS)。图一般用邻接矩阵或者邻接表来储存，本实现代码中 采用词典来存储,相比于邻接矩阵，词典方式来存储会导致访问并没有那么快，因为需要遍历key对应的list才可以找到想要的边。 另外，无论是dfs还是bfs其实跟树遍历(因为树也是一种图，无环图)一样，用到的辅助数据结构都是queue(BFS)或者stack(DFS) 实现代码 import...
栈的应用dfs - C++实现
CC_且听风吟丶的博客
06-26 1448
深搜dfs 都用到了上一篇的mystack栈 1. 不打印路径的版本 #include <iostream> #include <ctime> #include "mystack" #define MAXROW 10 #define MAXLINE 10 using namespace std; typedef struct _Point { int ...
深度优先搜索（DFS）C++实现
一面之媛
06-04 6264
算法基本思想： 深度优先搜索是尽可能深的搜索一个图，对于一个新发现的节点，如果还有以此为起点还未探测到的边，就沿此边探测下去。 当顶点v的所有边都被探寻过后，搜索将回溯到发现顶点v的起始点的那些边。这一过程一直进行到一发现从原点可达的所有点为止。 如果还存在未发现的顶点，则选择其中一个座位源顶点，重复上过程。 递归实现 void DFS_Search(ListNode* pRoot) ...
有向图的表示、存储及DFS/BFS实现(C++)--丰富注释+功能完整版
肖邦的夜曲的专栏
05-18 2615
1 基本概念 1.1 图的定义   图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：                    G=(V，E)   其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。   注：   在线性表中，元素个数可以为零，称为空表；   在树中，结点个数可以为零，称为空树；   在图中，顶点个数不能为零，但可以没有边。 1.2 图的存储结构   考虑图的定义，图是由顶点和边组成的，分别考虑如何存储顶点、如何存储边。 1.2.1 邻接矩阵
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值