求算法，用邻接矩阵和邻接表创建一个图，实现深度和广度搜索，菜单形式，c语言的代码。无向无权的图。

Posted 2023-05-04

采用手动和文件2种方式输入数据。

参考技术A 这是用邻接表创建的一个图
实现了广度和深度遍历
希望能帮助你
#include <iostream>
using namespace std;

#define MaxSize 50

struct ArcNode // 保存结点后面的所连边对应的点

int adjvex;
struct ArcNode * nextarc;
;

// 用来存放一个节点的结构体,存放首节点,后面定义的是一个结构体数组
struct Vnode

int data;
struct ArcNode * firstarc;
;

int m,n,v;

void creatgraph(struct Vnode A[MaxSize]); // 创建图
void dfs(struct Vnode A[MaxSize]); // 深搜
void bfs(struct Vnode A[MaxSize]); // 广搜

int main()

struct Vnode AdjList[MaxSize];
int cord;
do

cout<<" 主菜单"<<endl;
cout<<" 1 建立无向图的邻接表"<<endl;
cout<<" 2 按深度遍历图"<<endl;
cout<<" 3 按广度遍历图"<<endl;
cout<<" 4 结束程序运行"<<endl;
cout<<"------------------------------"<<endl;
cout<<" 请输入你的选择1 ,2 ,3 ,4:"<<endl;
cin>>cord;
switch(cord)

case 1:creatgraph(AdjList);break;
case 2:dfs(AdjList);break;
case 3:bfs(AdjList);break;
case 4:exit(0);

while(cord <= 4);

return 0;


void creatgraph(struct Vnode A[MaxSize]) //创建图

int i,j,k;
struct ArcNode *p;
cout<<" 输入边和点的个数:"<<endl;
cin>>m>>n; // m代表边的个数 ，n代表顶点个数
for(k=0;k<n;k++) // 首先对邻接表的所有顶点初始化

A[k].data = k+1;
A[k].firstarc = NULL;


for (k=0;k<m;k++) // 输入边,并插入到邻接表

cout<<" input arc:"<<endl;
cin>>i>>j; // 这代表一条无向边,顶点i与顶点j相连
p = (struct ArcNode *)malloc(sizeof(struct ArcNode));
p->adjvex = j;
p->nextarc = A[i-1].firstarc;
A[i-1].firstarc=p;

p = (struct ArcNode *)malloc(sizeof(struct ArcNode));
p->adjvex = i;
p->nextarc = A[j-1].firstarc;
A[j-1].firstarc=p;

cout<<endl;
for(k=0;k<n;k++) // 输出邻接表

cout<<" vex"<<A[k].data<<" arc is:";
p=A[k].firstarc;
while(p)

cout<<p->adjvex<<" ";
p=p->nextarc;

cout<<endl;


void dfs(struct Vnode A[MaxSize])

struct ArcNode *p, *ar[MaxSize];
int x,i,y,top=-1;
int visited[MaxSize];

for(i = 0 ; i < n ; i++) visited[i] = 0; // 这个数组用于代表这个节点是否被遍历过

cout<<"input x of start vex"<<endl;
cin>>x; // 输入从哪个节点开始遍历
cout<<x;

visited[x-1]=1; // 首先根节点被发现
p=A[x-1].firstarc; // 然后要遍历的是根节点的邻接点
while( (p) || top>=0) // 直到栈为空,并且没有邻接点就退出循环

if(!p) // 出栈

p = ar[top];
top--;


y = p->adjvex;

if(visited[y-1] == 0)

visited[y-1] = 1; // 被发现
cout<<" -> "<<y;
p = p->nextarc;
if(p) top++;ar[top] = p; // 入栈
p=A[y-1].firstarc;

else
p=p->nextarc;


void bfs(struct Vnode A[MaxSize])

struct ArcNode *p;
int x,i,y,front=-1,rear=-1,ar[MaxSize],visited[MaxSize];

for(i=0;i<n;i++) // 这个数组用于代表这个节点是否被遍历过
visited[i]=0;

cout<<"input x"<<endl;
cin>>x; // 代表从哪个节点开始遍历
cout<<x;

visited[x-1]=1; //代表x的结点被发现
p=A[x-1].firstarc; // x被发现之后就遍历x的邻接点
while( (p) || (front!=rear)) // 如果队列为空,并且这个结点没有了邻接点则退出循环


if (!p) // 这个当p的邻接点全部入队之后进入这句

front++; //队列的队首元素的下标往下偏移
y=ar[front]; //首先y出队,即去队首元素
p=A[y-1].firstarc; //之后就要遍历y的邻接点了


y=p->adjvex; //取p的数据域
if(visited[y-1] == 0)

visited[y-1]=1;
cout<<" -> "<<y;
rear++; //把p的邻接点全部入队,知道遍历到p没有邻接点为止
ar[rear]=y;

p=p->nextarc;

参考技术B #include<stdio.h>
#include<malloc.h>
#define NULL 0
#define maxvernum 100
typedef struct node

int adjvex;
struct node *next;
nodetype;
typedef struct frontnode

int data;
struct node *next;
frontnodetype;
frontnodetype adjlist[maxvernum];
/*********************************************/
void main()

void bfs(frontnodetype g[],int v,int c[]);
void travelgraph(frontnodetype g[],int n);
frontnodetype adjlist[6];
int i,j,m;
for(i=1;i<=5;i++)

adjlist[i].data=i;
adjlist[i].next=NULL;

for(j=1;j<=5;j++)

printf("进入第%d次循环\n",j);
printf("开始输入前请输入一个不为0的m值以便输入\n");
scanf("%d",&m);
while(m!=0)

int x;
printf("请输入结点序号（x=0表示后面没有结点）：\n");
if(x!=0)

scanf("%d",&x);
nodetype *p;
p=(nodetype *)malloc(sizeof(nodetype));
p->adjvex=x;p->next=NULL;
p->next=adjlist[j].next;
adjlist[j].next=p;

else break;
printf("是否停止？（m为0时停止输入，m为1时继续输入。）\n");
scanf("%d",&m);


printf("广度优先搜索序列为：\n");
travelgraph(adjlist,5);

/************************************************/
void bfs(frontnodetype g[],int v,int c[])

int q[6],r=0,f=0;
nodetype *p;
c[v]=1;
printf("%d\n",v);
q[0]=v;
whille(f<=r)

v=q[f++];
p=g[v].next;
while(p!=NNLL)

v=p->adjvex;
if(c[v]==0)

c[v]=1;
printf("%d\n",v);

p=p->next;



/************************************************/
void travelgraph(frontnodetype g[],int n)

int v;
int c[6];
for(v=1;v<=n;v++)
c[v]=0;
for(v=1;v<=n;v++)
if(c[v]==0)
dfs(g,v,c);

追问

怎么输出矩阵和表啊，求解释。

本回答被提问者采纳 参考技术C 深度用递归
广度用队列…… 参考技术D 大虎；2馄饨.4烈焰 2虎；2巨木.3金铭 3虎i；5金铭.大沧海 4虎；4金铭3沧海5虎；2烈焰大馄饨

JS实现图的创建和遍历

图分为无向图和有向图 

图的存储结构有邻接矩阵、邻接表、十字链表、邻接多重表这四种，最常用的是前两种

本篇主要是利用邻接矩阵实现无向图的创建和遍历（深度优先、广度优先），深度优先其实就是二叉树里的前序遍历

 

  

 

 

利用邻接矩阵（边数组）创建图

let scanf = require(\'scanf\');
//定义邻接矩阵
let Arr2 = [
    [0, 1, 0, 0, 0, 1, 0, 0, 0],
    [1, 0, 1, 0, 0, 0, 1, 0, 1],
    [0, 1, 0, 1, 0, 0, 0, 0, 1],
    [0, 0, 1, 0, 1, 0, 1, 1, 1],
    [0, 0, 0, 1, 0, 1, 0, 1, 0],
    [1, 0, 0, 0, 0, 0, 1, 0, 0],
    [0, 1, 0, 1, 0, 1, 0, 1, 0],
    [0, 0, 0, 1, 1, 0, 1, 0, 0],
    [0, 1, 1, 1, 0, 0, 0, 0, 0],
]

let numVertexes = 9, //定义顶点数
    numEdges = 14; //定义边数

// 定义图结构  
function MGraph() {
    this.vexs = []; //顶点表
    this.arc = []; // 邻接矩阵，可看作边表
    this.numVertexes = null; //图中当前的顶点数
    this.numEdges = null; //图中当前的边数
}
let G = new MGraph(); //创建图使用

//创建图
function createMGraph() {
    G.numVertexes = numVertexes; //设置顶点数
    G.numEdges = numEdges; //设置边数

    //录入顶点信息
    for (let i = 0; i < G.numVertexes; i++) {
        G.vexs[i] = scanf(\'%s\'); //String.fromCharCode(i + 65); ascii码转字符
    }
    console.log(G.vexs) //打印顶点

    //邻接矩阵初始化
    for (let i = 0; i < G.numVertexes; i++) {
        G.arc[i] = [];
        for (j = 0; j < G.numVertexes; j++) {
            G.arc[i][j] = Arr2[i][j]; //INFINITY; 
        }
    }

    /**以下是手动录入的方式 */
    // for (let k = 0; k < G.numEdges; k++) {
    //     console.log(\'输入边（vi,vj）上的下标i,下标j和权w:\');
    //     let rlt = scanf(\'%d,%d,%d\');
    //     let i = rlt[0], j = rlt[1], w = rlt[2];
    //     G.arc[i][j] = w;
    //     G.arc[j][i] = G.arc[i][j]; //无向图，矩阵对称
    // }

    console.log(G.arc); //打印邻接矩阵
}

深度优先遍历

let visited = []; //访问标志数组，遍历时使用

//邻接矩阵的深度优先递归算法
function DFS(i) {
    visited[i] = true;
    console.log(\'打印顶点:\', G.vexs[i]) //打印顶点 ,也可以其他操作
    for (let j = 0; j < G.numVertexes; j++) {
        if (G.arc[i][j] == 1 && !visited[j]) {
            console.log(G.vexs[i], \'->\', G.vexs[j])
            DFS(j) //对未访问的顶点进行递归
        }
    }
}
//邻接矩阵的深度遍历操作
function DFSTraverse() {
    for (let i = 0; i < G.numVertexes; i++) {
        visited[i] = false;
    }
    for (let i = 0; i < G.numVertexes; i++) {
        if (!visited[i])
            DFS(i)
    }
}

广度优先遍历

//邻接矩阵的广度遍历算法
function BFSTraverse() {
    let queue = []; //初始化队列
    for (let i = 0; i < G.numVertexes; i++) {
        visited[i] = false;
    }
    for (let i = 0; i < G.numVertexes; i++) { //对每一个顶点做循环
        if (!visited[i]) { //如果没有访问过就处理
            visited[i] = true;
            console.log(\'打印顶点：\', G.vexs[i]) //也可以是其他操作
            queue.push(i); //将此顶点入队列
            while (queue.length != 0) { //当前队列不为空
                queue.shift();
                for (let j = 0; j < G.numVertexes; j++) {
                    //判断其他顶点若与当前顶点存在边且未访问过
                    if (G.arc[i][j] == 1 && !visited[j]) {
                        visited[j] = true;
                        console.log(G.vexs[i], \'->\', G.vexs[j])
                        console.log(\'打印顶点：\', G.vexs[j])
                        queue.push(j) //将此顶点放入队列
                    }
                }
            }
        }
    }
}

运行：

console.log(\'**********创建图结构**********\');

createMGraph();

console.log(\'**********广度优先遍历**********\');

DFSTraverse();

console.log(\'**********广度优先遍历**********\');

BFSTraverse();

结果：