图的遍历之DFS与BFS

【数据结构】图的遍历:广度优先(BFS),深度优先(DFS) 算法思想,广度优先生成树,深度优先生成树,算法实现 阅读详情

参考: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 算法与无向图的完全相同,因为有向图的存储方式与无向图是完全相同的,只不过有向图存储的是只是单向而已。

图的遍历-----深度优先遍历(dfs),广度优先遍历(bfs)【java详解】 图的遍历是指,从给定图中任意指定的顶点(称为初始点)出发,按照某种搜索方法沿着图的边访问图中的所有顶点,使每个顶点仅被访问一次,这个过程称为图的遍历。遍历过程中得到的顶点序列称为图遍历序列。深度优先搜索(DFS,Depth First Search)广度优先搜索(BFS,Breadth First Search) 阅读详情

相关推荐

数据结构与算法(7-2)图的遍历(深度优先遍历DFS、广度优先遍历BFS)(分别用邻接矩阵和邻接表实现)

一、深度优先遍历(DFS)

great_yzl的博客 4363

DFS与BFS以及图的存储以及遍历

【代码】DFS与BFS以及图的存储以及遍历。

m0_74911187的博客 162

python实现图(基于图的不同存储方式)的深度优先(DFS)和广度(BFS)优先遍历

对于图在计算机内不同的存储方式,图的深度和广度优先遍历算法的写法也不同,但是两种算法的基本思想不变的,本文介绍不同方式存储的图的两种遍历方法的实现。

time_money的博客 2840

Android四大组件-Activity

目录 Activity 一、Activity生命周期 二、常见情况: 启动问题: 回收问题:Activity被回收的情况可能如下: 回收后数据存储问题:成对出现的onSaveInstanceState、onRestoreInstanceState Activity配置问题:为了让Activity不重新创建 Activity属性设置: Activity启动的设置: Activit...

zh1豪的博客 492

Oracle11g安装教程、配置实例、监听、客户端程序详解_Windows篇

Oracle11g安装教程、配置实例、监听、客户端程序详解_Windows篇 文章目录Oracle11g安装教程、配置实例、监听、客户端程序详解_Windows篇前言一、数据库的安装前准备,前提是没有安装过!!!二、仅安装数据库软件(数据库运行环境)三、添加数据库实例四、设置监听程序,让数据库可以通过网络访问五、为目标数据库设置网名总结 前言 如果需要安装包:联系我看到会给你链接,因为现在官网已经不提供10g,11g的安装包了,在网盘保存望悉知(回复不会很及时,下班看到会回复敬请谅解)。 提示:以下

zhx__的博客 5634

语音增强评价指标全解析:从MOS到eSTOI的实战指南

本文全面解析了语音增强领域的核心评价指标,包括主观评价的黄金标准MOS,以及PESQ、STOI、eSTOI等关键客观指标。文章详细阐述了各指标的原理、适用场景与实战计算方法,并提供了Python代码示例,旨在帮助开发者和研究者建立科学的评估体系,以平衡语音可懂度与音质,从而优化算法效果。

yhn456789的博客 1201

图的最短路径之Dijkstra算法

参考:https://wangkuiwu.github.io/2013/04/14/dijkstra-cplus Dijkstra算法介绍 迪杰斯特拉(Dijkstra)算法是典型最短路径算法,用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止。 算法基本思想: 通过 Dijkstra 计算图 G 中的最短路径时,需要指定起点 s(即从顶点 s 开始计算)。 此外,还需要引进两个集合 S 和 U。S 的作用是记录已求出最短路径的顶点(以及

code_peak 867

WebRTC音频传输实战:从采集到播放的完整链路解析(附RTP包处理细节)

本文深入解析了WebRTC音频传输的完整链路,从麦克风采集、音频处理与编码,到RTP打包、网络发送,再到接收端的NetEQ抗抖动处理与最终播放。文章以Linux PulseAudio为例,详细剖析了线程模型、缓冲区管理及RTP包处理等关键细节,旨在帮助开发者优化实时音频应用的延迟、卡顿与回声问题。

tea88的博客 853

BFS和DFS的简单遍历(C++实现)and Java实现bfs

头文件: //#include<bits/stdc++.h> #include<stdio.h> #include<algorithm> #include<iostream> #include<stdlib.h> #include<vector> #include<queue> #include<stack&...

浦柳人的博客 1827

【WorkBuddy】WorkBuddy 智能体快速上手:从零到一的实践指南

文章摘要: 传统自动化脚本难以应对灵活多变的自然语言需求,导致逻辑复杂、维护成本高。智能体(Agent)通过理解语义意图、动态决策和松耦合组件解决了这些问题。WorkBuddy采用声明式配置,通过可视化界面定义意图、实体和对话策略,无需编码即可快速构建智能体。其核心组件包括意图分类、实体提取、对话策略、故事样本和回退机制,适用于客服支持、知识问答等高频场景。通过环境准备(Python/Node.js/Redis)和简单配置,用户可以快速搭建可运行的智能体,显著提升自动化效率。

ruiqideng的博客 1711

python实现语音信号的分帧、加窗、预处理

语音信号实现分帧、加窗、预处理音频文件读取预加重分帧加窗 音频文件读取 librosa是非常强大的python语音信号处理库。 读取音频: 使用语句librosa.load(path, sr=22050, mono=True, offset=0.0, duration=None)读取音频文件,默认的采样率是22050,若要保留音频的原始采样率,使用sr=None。 其中: path:表示音频文件的路径 sr:表示采样率 mono:bool,是布尔类型,表示是否将信号转换为单声道 offset:float,后

weixin_45272908的博客 1万+

广度优先遍历(邻接表,邻接矩阵)

广度优先遍历(邻接表,邻接矩阵)

q322359的博客 9498

YOLOv8车辆碰撞识别检测系统(项目源码+YOLO数据集+模型权重+UI界面+python+深度学习+环境配置+目标检测)

随着我国汽车保有量的持续攀升,道路交通事故数量居高不下,车辆碰撞损伤的快速、精准评估已成为交通安全管理、保险理赔定损以及汽车后市场服务中的关键环节。传统的人工目视查验方法高度依赖评估人员的专业经验,不仅主观性强、效率低下,而且在复杂光照、多角度遮挡等真实场景下难以保证评估的一致性和可复现性。计算机视觉与深度学习技术的迅猛发展,为目标检测任务提供了强有力的技术支撑,使得基于视觉的车辆损伤自动化识别成为可能。

斌擎科技 132

图的遍历(广度优先遍历BFS,深度优先遍历DFS)

详细介绍了图的广度优先遍历(BFS)和深度优先遍历(DFS),涉及代码均有用图进行描述,非常详细!!!

2301_80035594的博客 2441

InvocationException: GraphViz‘s executables not found【BUG已解决】

在机器学习框架中遇到了一个bug:安装了GraphViz模块后,在对着sklearn的决策树文档操作输出决策树模型结果时,还是爆出了如下的错误: 报错位置为: 报错语句为:网上很多答案告诉我们,要我们安装GraphViz模块,然而并不对! 如下,我安装了GraphViz,但是还是报错了。 所以说问题不在这,我查阅质料发现,改正这个bug的方法有一个:下文详细描述。解决bug为: 1.去graphviz.官方下载自己电脑符合的操作系统的安装包:2,安装的时候,记住自己安装在电脑里的位置:以我的电脑为例,我的

一键难忘的博客 3971

uniapp:实现APP获取陀螺仪数据、加速传感器、线性加速传感器,uniApp实时监听陀螺仪【XYZ】数据及停止监听与资源释放等功能示例源码,根据需求做功能(完美兼容Android安卓、苹果ios)

uniapp陀螺仪,uniapp加速传感器,uniapp线性加速传感器,APP陀螺仪数据,uniapp app 端获取陀螺仪数据示例代码,手机中获取陀螺仪的数据,uniApp实时获取陀螺仪xyz数据,android陀螺仪方向,获得陀螺仪传感器,处理传感器数据,停止监听与资源释放,Android使用陀螺仪,uniapp苹果ios陀螺仪,uni-app设备之(加速计,罗盘,陀螺仪)插件安卓/IOS APP提供了获取陀螺仪数据的能力,手机陀螺仪传感器获得手机自身旋转的角度,陀螺仪获取旋转角度,陀螺仪、加速度传感器

✅ 精选推荐文章 4270

图的遍历(深度优先遍历DFS,广度优先遍历BFS)以及C语言的实现

遍历的定义: 从已给的连通图中某一顶点出发,沿着一些边访遍图中所有的顶点,且使每个顶点仅被访问一次,就叫做图的遍历,它是图的基本运算. 一:深度优先遍历(DFS) 1,在访问图中某一起始顶点V后,由V出发,访问它的任一邻接顶点W1 2,再从W1出发,访问与W1邻接但还未被访问过的顶点W2; 3,然后再从W2出发,进行类似的访问...... 4,如此进行下去,直至到达所有的邻接顶点都被访问过的顶点U为止. 5,接着,退回一步,退到前一次刚访问过的顶点,看是否还有其它没有被访问过的邻接点 6,如

any_ways的博客 3万+

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Java图的表示与遍历(深度优先算法DFS+广度优先算法BFS)

1.图的表示 图的表示方式有两种:二维数组表示(邻接矩阵);链表表示(邻接表) 邻接矩阵是表示图形中顶点之间相邻关系的矩阵,对于n个顶点的图而言,矩阵是的row和col表示的是1…n个点。 邻接矩阵需要为每个顶点都分配n个边的空间,其实有很多边都是不存在,会造成空间的一定损失. 邻接表的实现只关心存在的边,不关心不存在的边。因此没有空间浪费,邻接表由数组+链表组成 为了表示方便,之后的图用二维...

m0_38036210的博客 1667

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

图的遍历(搜索)算法(深度优先算法DFS和广度优先算法BFS)

从图的某个顶点出发访问遍图中所有顶点,且每个顶点仅被访问一次。(连通图与非连通图)

sinat_41942180的博客 1700

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

【数据结构】六、图:4.图的遍历(深度优先算法DFS、广度优先算法BFS)

图的遍历是和树的遍历类似,我们希望从图中某一顶点出发访遍图中其余顶点,且使每一个顶点仅被访问一次, 这一过程就叫做图的遍历(Traversing Graph)。 对于图的遍历来,通常有两种遍历次序方案: 深度优先遍历 广度优先遍历 1.1 深度优先遍历DFS 深度优先遍历(Depth First Search),也有称为深度优先搜索,简称为DFS。 1.1.1 DFS算法 深度优先搜索类似于树的先序遍历。如其名称中所暗含的意思一样,这种搜索算法所遵循的搜索策略是尽可能“深”地搜索一个图,每次都尝试向更

关注:https://github.com/Suhan42 4997

【数据结构和算法】图的遍历(深度优先遍历DFS与广度优先遍历BFS)

图的遍历 遍历定义: (遍历的实质:找到每个顶点的邻接点的过程) 图的遍历特点 解决重复遍历方法 图的遍历 1、深度优先遍历 方法: 例子: (连通图的深度优先遍历类似于树的先跟遍历,走不动再往回退) 思想思路 (其中辅助数组visited[n],一开始初始化为0,访问到就初始化为1。) 算法实现 代码如下: void DFS(AMraph G...

Clichong 3613

基于图的深度优先遍历(DFS)与广度优先遍历(BFS)

注意:本篇博文主要注重具体实现,适合于有一定数据结构基础的读者。 初始化:假设给定图G的初态是所有顶点均未曾访问过。 在G中任选一顶点v为初始出发点(源点)。 深度优先遍历:首先访问出发点v,并将其标记为已访问过;然后依次从v出发搜索v的每个邻接点w。若w未曾访问过,则以w为新的出发点继续进行深度优先遍历,直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。依次遍历

mingwanganyu的博客 2018

分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_图的BFS、DFS

BFS、DFS分别为广度优先搜索和深度优先搜索的英文首字母缩写。先考虑树的BFS、DFS。树的BFS即层序遍历。层序遍历先访问根结点,再逐个访问根结点的子结点,再逐个访问上述子结点的子结点,以此类推,直至访问过所有结点。树的DFS有三种(先序遍历、中序遍历、后序遍历),这里只说先序遍历。先序遍历先访问根结点,再逐个先序遍历根结点的所有子树。(由递归的定义可知,容易用递归算法实现(函数的递归用到了调...

weixin_39527768的博客 4584

实现图的广度优先遍历(BFS)和深度优先遍历(DFS)

这段代码首先定义了图的数据结构和基本操作,然后实现了BFS和DFS算法。在`main`函数中,创建了一个简单的图,并进行了BFS和DFS遍历。请注意,这个示例代码没有进行错误检查,例如内存分配失败,这在实际应用中是必要的。C语言中实现图的广度优先遍历(BFS)和深度优先遍历(DFS)通常涉及到使用队列和栈数据结构。// 添加从src到dest的边。// 定义图的节点结构。// 创建一个新的节点。// 检查队列是否为空。// 检查栈是否为空。

2303_79540797的博客 1270

图的遍历、深度优先DFS、广度优先BFS

之前我们讲了用多种方法来实现图的存储,那么当图被创建出来后要怎么去遍历呢?我们知道像邻接矩阵之类的存储结构的核心是通过数组实现的,那么在遍历邻接矩阵的时候只需要用循环遍历数组一样遍历它就行了;对于像邻接表之类的存储结构的核心是使用链表实现的,那么在遍历的时候,我们可以用遍历链表一样的方法。但是这样在实际运用中会很麻烦,那么有没有一种不用区分图的存储结构,都能实现图的遍历的结构呢?解决这个问题之前,我们要清楚什么是图的遍历。简单而言就是从某一个顶点出发,按照某种搜索方式把图中顶点都访问一遍且仅访问一遍,这个过

ZER00000001的博客 628
上一篇: C++11的Lambda函数
下一篇: 图的拓扑排序
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值