图的遍历之DFS与BFS

最新推荐文章于 2024-07-15 17:29:31 发布
最新推荐文章于 2024-07-15 17:29:31 发布
阅读量263 收藏 2
点赞数
分类专栏： 数据结构
原文链接：https://wangkuiwu.github.io/2013/04/10/iterator/
版权

参考：https://wangkuiwu.github.io/2013/04/10/iterator

深度优先搜索DFS

图的深度优先遍历（Depth First Search）和树的先序遍历有一定相似之处，它的基本思想是：假设初始状态是图中所有顶点均未被访问，则从某个顶点 v 出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和 v 有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。

显然，深度优先搜索是一个递归地过程。

无向图的深度优先搜索

以下面的无向图为例，对无向图深度优先搜索进行演示：

图的遍历-图1

图 G1

对图 G1 进行深度优先遍历，从顶点 A 开始。

图的遍历-图2

其访问步骤如下：

第一步：访问 A。

第二步：访问 C（A 的邻接结点）。在第 1 步访问 A 之后，接下来应该访问的是 A 的邻接点，即 C, D, F 中的一个，但在本文的实现中，顶点A, B, C, D, E, F, G 是按照顺序存储，C 在 D 和 F 的前面，因此，先访问 C。

第三步：访问 B（C 的邻接点）。在第 2 步访问 C 之后，接下来应该访问 C 的邻接点，即 B 和 D 中的一个（因为 A 被访问过，所以不算），而由于 B 在 D 之前，先访问 B。

第四步：访问 D（C 的邻接点）。在第 3 步访问了 C 的邻接点 B 之后，B 已经没有未被访问的邻接点；因此，返回到访问 C 的另一个邻接点 D。

第五步：访问 F（A 的邻接点）。前面已经访问了 A，并且访问完了 A 的邻接点 C 的所有邻接点（包括递归的邻接点在内）；因此，此时返回到访问 A 的另一个邻接点 F。

第六步：访问 G（F 的邻接点）。

第七步：访问 E（G 的邻接点）。

因此，访问顺序是：A -> C -> B -> D -> F -> G -> E。

有向图的深度优先搜索

以下面有向图为例，来对有向图深度优先搜索进行演示：

图的遍历-图3

图 G2

对上面的图 G2 进行深度优先遍历，从顶点 A 开始。

图的遍历-图4

其访问步骤如下：

第一步：访问 A。

第二部：访问 B。在访问了 A 之后，接下来应该访问的是 A 的出边的另一个顶点，即顶点 B。

第三步：访问 C。在访问了 B 之后，接下来应该访问的是 B 的出边的另一个顶点，即顶点 C, E, F，在本文实现的图中，顶点 A, B, C, D, E, F, G 按照顺序存储，因此先访问 C。

第四步：访问 E。接下来访问 C 的出边的另一个顶点，即顶点 E。

第五步：访问 D。接下来访问 E 的出边的另一个顶点，即顶点 B, D。顶点 B 已经被访问过了，因此访问顶点 D。

第六步：访问 F。接下来应该回溯到访问 B 的出边的另一个顶点 F。

第七步：访问 G。

因此，访问顺序是：A -> B -> C -> E -> D -> F -> G。

广度优先搜索BFS

广度优先搜索算法（Breadth First Search）又称为“宽度优先搜索”或“横向优先搜索”，简称 BFS。它的基本思想是：从图中某顶点 v 出发，在访问了 v 之后依次访问 v 的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。

换句话说，广度优先搜索遍历图的过程是以 v 为起点，由近至远，依次访问和 v 有路径相通且路径长度为 1, 2, … 的顶点。

无向图的广度优先搜索

下面以“无向图”为例，来对广度优先搜索进行演示。还是以上面图 G1 为例进行说明。

图的遍历-图5

第一步：访问 A。

第二部：依次访问 C, D, F。在访问了 A 之后，接下来访问 A 的邻接点。前面已经说过，在文本实现中，顶点 A, B, C, D, E, F, G 是按照顺序存储的，C 在 D 和 F 的面前，因此，先访问 C。在访问完 C 之后，再依次访问 D, F。

第三步：访问 B, G。再第 2 步访问完 C, D, F 之后，再依次访问它们的邻接点。首先访问 C 的邻接点 B，再访问 F 的邻接点 G。

第四步：访问 E。再第三步访问完 B, G 之后，再依次访问它们的邻接点。只有 G 有邻接点 E，因此访问 G 的邻接点 E。

因此访问顺序是：A -> C -> D -> F -> B -> G -> E。

有向图的广度优先搜索

下面以“有向图”为例，来对广度优先搜索进行演示。还是以上面的图 G2 为例进行说明。

图的遍历-图6

第一步：访问 A。

第二部：访问 B。

第三步：依次访问 C, E, F。在访问了 B 之后，接下来访问 B 的出边的另一个顶点，即 C, E, F。前面已经说过，在文本实现中，顶点 A, B, C, D, E, F, G 是按照顺序存储的，因此会先访问 C，再依次访问 E, F。

第四步：依次访问 D, G。在访问完 C, E, F 之后，再依次访问它们的出边的另一个顶点。还是按照 C, E, F 的顺序访问，C 的已经全部访问过了，那么就只剩下 E, F；先访问 E 的邻接点 D，再访问 F 的邻接点 G。

因此访问顺序是：A -> B -> C -> E -> D -> G。

代码实现

此代码实现基于之前的：无向图的邻接矩阵与邻接表详细实现和有向图的邻接矩阵与邻接表详细实现。

无向图(邻接矩阵)的DFS与BFS实现

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

#define MAX 100

class MatrixUDG
{
private:
    char mVexs[MAX];       //顶点集合，如：{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int mVexNum;           //顶点数，如：7
    int mEdgNum;           //边数
    int mMatrix[MAX][MAX]; //邻接矩阵
public:
    //创建图(手动输入)
    MatrixUDG();
    //创建图(用提供的顶点和边)
    MatrixUDG(char *vexs, int vNum, char (*edges)[2], int eNum);
    ~MatrixUDG();
    //打印邻接表
    void print();
    //深度优先遍历
    void DFS();
    //广度优先遍历
    void BFS();

private:
    //输入一个合法字母
    char readChar();
    //获得一个字母在顶点数组的下标
    int getPosition(char ch);
    //返回顶点v的第一个邻接顶点的索引，失败返回-1
    int firstVertex(int v);
    //范围顶点v相对于w的下一个邻接顶点的索引，失败返回-1
    //比如: A和C, D, E有连接，则A相对于C的下一个结点为D，即返回D的索引
    int nextVertex(int v, int w);
    //深度优先搜索遍历图的递归实现
    void DFS(int i, int *visited);
};

MatrixUDG::MatrixUDG()
{
    char c1, c2;
    int p1, p2;
    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数：";
    cin >> mEdgNum;
    if (mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误！" << endl;
        return;
    }
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i] = readChar();
    }
    for (int j = 0; j < mEdgNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边错误！" << endl;
            return;
        }
        mMatrix[p1][p2] = 1;
        mMatrix[p2][p1] = 1;
    }
}

MatrixUDG::MatrixUDG(char *vexs, int vNum, char (*edges)[2], int eNum)
{
    if (vNum > MAX)
        return;
    mVexNum = vNum;
    mEdgNum = eNum;
    //初始化顶点
    for (int i = 0; i < mVexNum; ++i)
        mVexs[i] = vexs[i];
    int p1, p2;
    for (int j = 0; j < mEdgNum; ++j)
    {
        //获得边的起始点和结束点
        p1 = getPosition(edges[j][0]);
        p2 = getPosition(edges[j][1]);
        //将连线的两个点都置为1
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边错误！" << endl;
            return;
        }
        mMatrix[p1][p2] = 1;
        mMatrix[p2][p1] = 1;
    }
}

MatrixUDG::~MatrixUDG()
{
}

int MatrixUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i] == ch)
            return i;
    }
    return -1;
}

char MatrixUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

void MatrixUDG::print()
{
    for (int i = 0; i < mVexNum; ++i)
    {
        for (int j = 0; j < mVexNum; ++j)
        {
            cout << mMatrix[i][j] << " ";
        }
        cout << endl;
    }
}

/*
返回顶点v的第一个邻接顶点的索引，失败返回-1
*/
int MatrixUDG::firstVertex(int v)
{
    if (v < 0 || v > (mVexNum - 1))
        return -1;
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] == 1)
            return i;
    }
    return -1;
}
/*
返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
比如:A和C,D,E有连接，则A相对于C的下一个结点为D，即返回D的索引
*/
int MatrixUDG::nextVertex(int v, int w)
{
    if (v < 0 || v > (mVexNum - 1) || w < 0 || w > (mVexNum - 1))
        return -1;
    for (int i = w + 1; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] == 1)
            return i;
    }
    return -1;
}

void MatrixUDG::DFS()
{
    int visited[MAX] = {0}; //顶点是否访问标记
    cout << "DFS:";
    for (int i = 0; i < mVexNum; ++i)
    {
        if (!visited[i])
        {
            DFS(i, visited);
        }
    }
    cout << endl;
}

void MatrixUDG::DFS(int i, int *visited)
{
    visited[i] = 1; //标记为访问过
    cout << mVexs[i] << " ";
    //返回-1终止循环
    for (int w = firstVertex(i); w >= 0; w = nextVertex(i, w))
    {
        if (!visited[w])
            DFS(w, visited);
    }
}

void MatrixUDG::BFS()
{
    int i = 0, j, k;
    int visited[MAX] = {0};
    std::queue<int> queue;
    cout << "BFS:";
    for (i = 0; i < mVexNum; ++i)
    {
        if (!visited[i])
        {
            visited[i] = 1;
            cout << mVexs[i] << " ";
            queue.push(i); //入队列
        }
        while (!queue.empty())
        {
            j = queue.front();
            queue.pop(); //出队列
            for (k = firstVertex(j); k >= 0; k = nextVertex(j, k)) //依次找到j的各个邻接点，然后访问再加到队列中
            {
                if (!visited[k])
                {
                    visited[k] = 1;
                    cout << mVexs[k] << " ";
                    queue.push(k); //入队列
                }
            }
        }
    }
    cout << endl;
}

int main()
{
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    char edges[][2] = {
        {'A', 'C'},
        {'A', 'D'},
        {'A', 'F'},
        {'B', 'C'},
        {'C', 'D'},
        {'E', 'G'},
        {'F', 'G'}};
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
    MatrixUDG mudg(vexs, vNum, edges, eNum);
    mudg.print(); //打印图
    mudg.DFS(); //深度优先遍历
    mudg.BFS(); //广度优先遍历
    //2. 手动生成
    // MatrixUDG mudg1;
    // mudg1.print();
    // mudg1.DFS();
}

运行结果如下：

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 
0 0 0 0 1 1 0 
DFS:A C B D F G E 
BFS:A C D F B G E

无向图(邻接表)的DFS与BFS实现

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

#define MAX 100

class ListUDG
{
private:
    //每一条边
    struct ENode
    {
        int iVex;               //指向的顶点的位置
        ENode *nextEdge = NULL; //指向顶点的下一条边的指针
    };
    //数组中存储的顶点
    struct VNode
    {
        char data;
        ENode *firstEdge = NULL; //指向第一条该顶点的边
    };

private:
    int mVexNum;      //图的顶点数目
    int mEdgeNum;     //图的边的数目
    VNode mVexs[MAX]; //存储顶点 如B的邻接点:C->E->F
public:
    ListUDG();
    ListUDG(char vexs[], int vNum, char edges[][2], int eNum);
    ~ListUDG();
    //打印邻接表
    void print();
    //深度优先搜索遍历
    void DFS();
    //广度优先搜索遍历
    void BFS();

private:
    //读取一个合法的输入字符
    char readChar();
    //返回字符ch在的位置
    int getPosition(char ch);
    //将node结点链接到list的最后
    void linkLast(ENode *list, ENode *node);
    //深度优先搜索遍历图的递归实现
    void DFS(int i, int *visited);
};

ListUDG::ListUDG()
{
    char c1, c2;
    int p1, p2;

    ENode *node1, *node2;
    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgeNum;
    if (mVexNum > MAX || mEdgeNum > MAX || mVexNum < 1 || mEdgeNum < 1 || (mEdgeNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误！" << endl;
        return;
    }
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i].data = readChar();
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误！" << endl;
            return;
        }

        node1 = new ENode();
        node1->iVex = p2;
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        node2 = new ENode();
        node2->iVex = p1;
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::ListUDG(char *vexs, int vNum, char (*edges)[2], int eNum)
{
    if (vNum > MAX || eNum > MAX)
        return;
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    mVexNum = vNum;
    mEdgeNum = eNum;
    for (int i = 0; i < mVexNum; ++i)
    {
        mVexs[i].data = vexs[i];
    }
    for (int j = 0; j < mEdgeNum; ++j)
    {
        c1 = edges[j][0];
        c2 = edges[j][1];
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误！" << endl;
            return;
        }
        node1 = new ENode();
        node1->iVex = p2;
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        node2 = new ENode();
        node2->iVex = p1;
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::~ListUDG() {}

void ListUDG::linkLast(ENode *list, ENode *node)
{
    ENode *p = list;
    while (p->nextEdge)
        p = p->nextEdge;
    p->nextEdge = node;
}

int ListUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i].data == ch)
            return i;
    }
    return -1;
}

char ListUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

//深度优先搜索遍历图的递归实现
void ListUDG::DFS(int i, int *visited)
{
    visited[i] = 1;
    cout << mVexs[i].data << " ";
    ENode *node = mVexs[i].firstEdge;
    while (node != NULL)
    {
        if (!visited[node->iVex])
        {
            DFS(node->iVex, visited);
        }
        node = node->nextEdge;
    }
}

//深度优先搜索遍历图
void ListUDG::DFS()
{
    int i = 0;
    int visited[MAX] = {0};
    cout << "DFS:";
    for (i = 0; i < mVexNum; ++i)
    {
        if (!visited[i])
        {
            DFS(i, visited);
        }
    }
    cout << endl;
}

void ListUDG::BFS()
{
    int visited[MAX] = {0};
    int i, j, k;
    std::queue<int> queue;
    ENode *node;
    cout << "BFS:";
    for (i = 0; i < mVexNum; ++i)
    {
        if (!visited[i])
        {
            visited[i] = 1;
            cout << mVexs[i].data << " ";
            queue.push(i);
        }
        while (!queue.empty())
        {
            j = queue.front(); //出队列
            queue.pop();
            node = mVexs[j].firstEdge;
            while (node != NULL)
            {
                k = node->iVex;
                if (!visited[k])
                {
                    visited[k] = 1;
                    cout << mVexs[k].data << " ";
                    queue.push(k);
                }
                node = node->nextEdge;
            }
        }
    }
    cout << endl;
}

void ListUDG::print()
{
    ENode *node;
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << i << "(" << mVexs[i].data << "):";
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            cout << node->iVex << "(" << mVexs[node->iVex].data << ")";
            node = node->nextEdge;
        }
        cout << endl;
    }
}

int main(int argc, char **argv)
{
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    char edges[][2] = {
        {'A', 'C'},
        {'A', 'D'},
        {'A', 'F'},
        {'B', 'C'},
        {'C', 'D'},
        {'E', 'G'},
        {'F', 'G'}};
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
    ListUDG ludg(vexs, vNum, edges, eNum);
    ludg.print();
    ludg.DFS();
    ludg.BFS();
    //2. 手动输入
    // ListUDG ludg;
    // ludg.print();
    return 0;
}

运行结果如下：

0(A):2(C)3(D)5(F)
1(B):2(C)
2(C):0(A)1(B)3(D)
3(D):0(A)2(C)
4(E):6(G)
5(F):0(A)6(G)
6(G):4(E)5(F)
DFS:A C B D F G E 
BFS:A C D F B G E

注：关于有向图的邻接矩阵和邻接表的 DFS 和 BFS 算法与无向图的完全相同，因为有向图的存储方式与无向图是完全相同的，只不过有向图存储的是只是单向而已。

code_peak
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
遍历算法DFS与BFS
qq_19445279的博客
03-04 728
遍历算法
Java数据结构——图的遍历(DFS+BFS)
NoBug
02-18 1050
文章目录一、图例二、深度优先搜索遍历（一）、定义（二）、数据结构（三）、Java代码三、广度优先搜索遍历（一）、定义 一、图例 访问序列： - DFS: v1->v2->v4->v8->v5->v3->v6->v7 - BDS: v1->v2->v3->v4->v5->v6->v7->v8 二、深度优先搜索遍历 （一）、定义 特点： 单向前进，回路回退。 二叉树： 前序遍历，中序遍历，后序遍历。 图的遍历： 从图中某
图——图的遍历（DFS与BFS算法详解）
Blusher1的博客
07-15 1739
前面的文章中我们学习了图的基本概念和存储结构，这篇文章就来学习一下图的重要章节——图的遍历。包含深度优先搜索（DFS）和广度优先搜索（BFS）两种方式。
图的遍历-DFS，BFS(代码详解)
热门推荐
weixin_64067830的博客
07-25 5万+
图的遍历-DFS，BFS(代码详解)！
【图】（二）图的遍历 - DFS与BFS - C语言
友人帐_的博客
10-30 1143
介绍了图的深度优先搜索与广度优先搜索。并分别给出了邻接矩阵与邻接表两种不同数据结构下的递归与非递归算法。
图的遍历（详解DFS与BFS）
CXR_XC的博客
11-11 9405
详解DFS和BFS的方法和具体实现，包括邻接矩阵和邻接表两种数据结构
图的遍历 —— DFS、BFS
一个很懒的人
08-29 5142
0.概要 本文主要从以下三个方面介绍图的遍历： 图的广度优先遍历（BFS） 图的深度优先遍历（DFS） 两种遍历一般性实现代码（C++） 1.图的广度优先遍历（BFS） （1）树 (层次遍历) VS 图 (BFS——广度优先遍历) （2）算法要点——BFS 连通图 非连通图 （3）遍历序列可变性 （4）空间复杂度 （5）时间复杂度 （6）广度优先生成树 对⾮连通图的⼴度优先遍历，可得到⼴度优先⽣成森林 1.图的广度优先遍历（BFS） （1）算法要点 （2）遍历序列可.
二叉树遍历及 DFS和BFS
喜大普奔
04-26 206
二叉树遍历(DFS,BFS)
数据结构 --- 图的遍历 DFS、BFS
weixin_60569662的博客
04-03 3660
什么是DFS、BFS？ 一条线走到底，深度优先遍历，每一个顶点只遍历、只打印一次的方式：DFS、BFS 数据结构 --- 图的存储_考拉爱睡觉鸭~的博客-CSDN博客 单纯地把邻接顶点的邻接顶点打印出来，顶点重复遍历，打印多次 从 A→F 所有的节点都遍历完了，需要做回退，从F回退到D点，找D点有没有邻接顶点，没有邻接顶点，继续做回退，退到B节点，有未访问的临接顶点，访问C顶点 如果遍历的节点已经被遍历了，不能重复遍历，要做回退 如果形成环状，也是重复遍历的情况，也要做回.........
C++数据结构之图的遍历——DFS和BFS（带有gif演示）
m0_56398315的博客
08-19 6122
本文介绍了继图的存储结构之后对图进行遍历，分为DFS和BFS两种算法，赋有动态gif图示和相关代码以及注释
邻接矩阵，邻接表实现图的创建，遍历(DFS,BFS)
05-12
在计算机科学中，图是一种非常重要的数据结构，用于表示对象之间的关系或连接。...DFS和BFS则是图遍历的重要算法，广泛应用于各种问题，如查找最短路径、检测环等。掌握这些知识对于理解和解决复杂问题具有重要意义。
二叉树遍历BFS与DFS详细代码python版
01-18
二叉树遍历BFS与DFS详细代码python版
邻接表存储的图的DFS，BFS遍历
04-06
本文将深入探讨使用邻接表存储的图进行深度优先遍历（DFS）和广度优先遍历（BFS）的方法。 **邻接表** 是一种高效的空间优化存储方式，尤其适用于稀疏图（边的数量远小于节点数量的平方）。在邻接表中，每个节点有...
基于邻接表存储的图的dfs与bfs遍历
11-26
基于邻接表存储的图的dfs与bfs遍历，对学习数据结构很有帮助
DFS+BFS深度+广度优先遍历.cpp
01-17
DFS+BFS深度+广度优先遍历.cpp
mpu6050陀螺仪使用方法开发教程文档.docx
07-30
mpu6050陀螺仪使用方法
【SCI顶级】龙格库塔算法RUN-CNN-LSTM-Multihead-Attention温度预测【含源码 5747期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Mutilhead-Attention回归预测
大模型的数学之魂：统计学习理论精要
07-30
大型机器学习模型，通常简称为“大模型”，是指具有数十亿甚至数千亿参数的深度神经网络模型。这些模型因为其庞大的参数量和复杂的计算结构，能够处理非常复杂的任务和数据，展现出强大的表达能力和预测性能。大模型在自然语言处理、计算机视觉、语音识别和推荐系统等多个领域都有广泛的应用。 大模型的设计目的是通过训练海量数据来学习复杂的模式和特征，从而具备强大的泛化能力，能够对未见过的数据做出准确的预测。与参数较少、层数较浅的小模型相比，大模型虽然需要更多的计算资源和时间来训练和推理，但它们展现出了一种被称为“涌现能力”的特性，即从原始训练数据中自动学习并发现新的、更高层次的特征和模式。 大模型的发展历程可以分为几个阶段，从早期的卷积神经网络模型发展到以Transformer为代表的全新神经网络模型，再到当前以GPT为代表的预训练大模型阶段。Transformer架构因其自注意力机制而成为大模型的核心技术，它使得模型能够更好地理解和处理文本数据中的长距离依赖关系。 大模型的分类主要包括语言大模型（NLP）、视觉大模型（CV）和多模态大模型。语言大模型专注于处理文本数据和理解自然语言，而视觉大模型用
唯美淡雅四页.zip
最新发布
07-30
【简历模板】工作总结、商业计划书、述职报告、读书分享、家长会、主题班会、端午节、期末、夏至、中国风、卡通、小清新、岗位竞聘、公司介绍、读书分享、安全教育、文明礼仪、儿童故事、绘本、防溺水、夏季安全、科技风、商务、炫酷、企业培训、自我介绍、产品介绍、师德师风、班主任培训、神话故事、巴黎奥运会、世界献血者日、防范非法集资、3D快闪、毛玻璃、人工智能等等各种样式的ppt素材风格。 设计模板、图片素材、PPT模板、视频素材、办公文档、小报模板、表格模板、音效配乐、字体库。 广告设计：海报，易拉宝，展板，宣传单，宣传栏，画册，邀请函，优惠券，贺卡，文化墙，标语，制度，名片，舞台背景，广告牌，证书，明信片，菜单，折页，封面，节目单，门头，美陈，拱门，展架等。 电商设计：主图，直通车，详情页，PC端首页，移动端首页，钻展，优惠券，促销标签，店招，店铺公告等。 图片素材：PNG素材，背景素材，矢量素材，插画，元素，艺术字，UI设计等。 视频素材：AE模板，会声会影，PR模板，视频背景，实拍短片，音效配乐。 办公文档：工作汇报，毕业答辩，企业介绍，总结计划，教学课件，求职简历等PPT/WORD模板。
图的遍历：C语言实现DFS与BFS
"这篇文档是关于C语言实现无向图的深度优先遍历(DFS)和广度优先遍历(BFS)的教程。文中详细介绍了如何使用邻接表存储图，以及两种遍历算法的思路和步骤。" 本文档重点讲述了在C语言中如何处理数据结构中的图问题，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值