邻接矩阵表示 深度遍历 广度遍历

邻接矩阵表示法是一种图的表示方法，其中每个顶点都有一个唯一的索引，而每条边则由两个顶点之间的连接确定。深度优先遍历（DFS）和广度优先遍历（BFS）是两种常用的图遍历算法。

1. 深度优先遍历（DFS）：

深度优先遍历从根节点开始，沿着一条路径尽可能深入地访问节点，直到到达叶子节点。然后回溯到上一个节点，继续访问其他未访问过的节点。这个过程一直持续到所有节点都被访问过为止。

在邻接矩阵表示法中，可以使用递归或栈来实现深度优先遍历。以下是使用栈实现的示例代码：

#include 
#include 
using namespace std;

void dfs(int matrix[][4], int start, bool visited[]) {
    stack s;
    s.push(start);
    visited[start] = true;

    while (!s.empty()) {
        int node = s.top();
        s.pop();
        cout << node << " ";

        for (int i = 0; i < 4; i++) {
            if (matrix[node][i] == 1 && !visited[i]) {
                s.push(i);
                visited[i] = true;
            }
        }
    }
}

int main() {
    int matrix[4][4] = {
        {0, 1, 1, 0},
        {1, 0, 0, 1},
        {1, 0, 0, 1},
        {0, 1, 1, 0}
    };
    bool visited[4] = {false};

    dfs(matrix, 0, visited);

    return 0;
}

 

2. 广度优先遍历（BFS）：

广度优先遍历从根节点开始，首先访问所有与根节点直接相连的节点，然后再访问这些节点的邻居节点，以此类推。这个过程一直持续到所有节点都被访问过为止。

在邻接矩阵表示法中，可以使用队列来实现广度优先遍历。以下是使用队列实现的示例代码：

#include 
#include 
using namespace std;

void bfs(int matrix[][4], int start, bool visited[]) {
    queue q;
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int node = q.front();
        q.pop();
        cout << node << " ";

        for (int i = 0; i < 4; i++) {
            if (matrix[node][i] == 1 && !visited[i]) {
                q.push(i);
                visited[i] = true;
            }
        }
    }
}

int main() {
    int matrix[4][4] = {
        {0, 1, 1, 0},
        {1, 0, 0, 1},
        {1, 0, 0, 1},
        {0, 1, 1, 0}
    };
    bool visited[4] = {false};

    bfs(matrix, 0, visited);

    return 0;
}

 

3. 邻接矩阵表示 深度遍历 广度遍历

 代码如下：

#include 
#include 
#include 

using namespace std;

#define MaxInt  32767
#define MVNum 100

typedef char VerTexType;
typedef int ArcType;
//邻接矩阵
typedef  struct {
    VerTexType  vexs[MVNum];  /*存储顶点元素*/
    ArcType arcs[MVNum][MVNum];
    /*各顶点之间的关系或权值*/
    int  vexnum, arcnum; /*顶点数，边（或弧）的个数*/
}MGraph;
int visited[MVNum];
int visitedBFS[MVNum];
stack mystack;
queue myqueue;
//函数声明
void PrintVisited();
int LocateVex(MGraph& G, VerTexType v); //函数定义
void CreateMGraph(MGraph& G);
void DFS(MGraph& G, VerTexType v);
void BFS(MGraph& G, VerTexType v);
void TestDemoGraph();

//函数定义

void  CreateMGraph(MGraph& G) {
    int i = 0, j = 0, k = 0;
    cout << "输入顶点个数：";
    cin >> G.vexnum;
    cout << "输入边的个数：";
    cin >> G.arcnum;
    for (i = 0; i < G.vexnum; i++) {
        cout << "输入第" << i + 1 << "个顶点的名称：";
        cin >> G.vexs[i];
    }

    for (i = 0; i < G.vexnum; ++i)         //初始化邻接矩阵，
        for (j = 0; j < G.vexnum; ++j)
            G.arcs[i][j] = 0;

    cout << "输入边依附的顶点 ，如 a b " << endl;
    VerTexType v1, v2;
    for (k = 0; k < G.arcnum; ++k) {							//构造邻接矩阵
        cout << "请输入第" << (k + 1) << "条边依附的顶点及权值：";
        cin >> v1 >> v2;								//输入一条边依附的顶点及权值
        i = LocateVex(G, v1);   //函数调用
        j = LocateVex(G, v2);		//确定v1和v2在G中的位置，即顶点数组的下标
        if (i == -1 || j == -1) {
            cout << "顶点名称错误" << endl;
            k--;
            continue;
        }
        G.arcs[i][j] = 1;								//边的值为1
        G.arcs[j][i] = G.arcs[i][j];						//置的对称边的权值为w
    }//for
}
int LocateVex(MGraph& G, VerTexType v) { //函数定义
    //确定点v在G中的位置
    for (int i = 0; i < G.vexnum; ++i)
        if (G.vexs[i] == v)
            return i;
    return -1;
}//LocateVex

void PrintVexArc(MGraph& G) {
    int i = 0, j = 0;
    cout << "顶点列表：" << endl;
    for (i = 0; i < G.vexnum; i++) {
        cout << "\t" << G.vexs[i];
    }
    cout << endl << "邻接矩阵：" << endl;
    for (i = 0; i < G.vexnum; i++) {
        for (j = 0; j < G.vexnum; j++) {
            cout << "\t" << G.arcs[i][j];
        }
        cout << endl;
    }
}

void PrintVisited() {
    for (int i = 0; i < 6; i++) cout << visited[i] << "\t"; cout << endl;
}
void PrintVisitedBFS() {
    for (int i = 0; i < 6; i++) cout << visitedBFS[i] << "\t"; cout << endl;
}
void DFS(MGraph& G, VerTexType v) {  //从v点开始深度遍历
    int index = LocateVex(G, v);
    if (index == -1) {
        cout << "没有这个结点" << v << endl;
        return;
    }
    if (visited[index] == 1) {  //已经访问过了，就返回。
        return;
    }
    //没有访问过，直接标记访问，操作，没有访问过的邻接点入栈
    visited[index] = 1; //标记当前结点已经访问过了
    cout << v << "\t"; //访问当前结点V，对该结点进行操作，直接输出。
    PrintVisited();
    int j = 0;
    for (j = G.vexnum; j >= 0; j--) {
        if (G.arcs[index][j] == 1 && visited[j] == 0) {
            mystack.push(G.vexs[j]);
        }
    }
    while (!mystack.empty()) {
        VerTexType vex = mystack.top();
        mystack.pop();
        DFS(G, vex);
    }
}

void BFS(MGraph& G, VerTexType v) {   //从v点开始广度遍历
    int index = LocateVex(G, v);
    if (index == -1) {
        cout << "没有这个结点" << v << endl;
        return;
    }
    if (visitedBFS[index] == 1) {
        return;
    }
    //没有被访问过，
    visitedBFS[index] = 1;
    cout << v << "\t";
    PrintVisitedBFS();
    for (int i = 0; i < G.vexnum; i++) {
        if (G.arcs[index][i] == 1 && visitedBFS[i] == 0) {
            //  cout<<"["<"<" << endl;
    DFS(G, 'b');
    cout << "BFS--->" << endl;
    BFS(G, 'b');
}
int main()
{
    TestDemoGraph();
    return 0;
}
/*
6
8
a
b
c
d
e
f
ab
af
ae
bc
bd
fd
ed
cd



*/

 

 运行结果：

 

加油各位！！