设图的邻接矩阵为 0 1 10 0 10 1 0,则该图为（ ）.A.有向图 B.无向图 C.强连通图 D.完全图

选A.因为无向图没有方向,所以相应的邻接矩阵是对称的

A

自己看相关资料

选A 无向图的邻接矩阵一定是对称的.因为如果一个点i到j有边,则aij=aji=1;所以都是对称的.但是有向图就不一定了,点i 到 j 有边,aij=1,但j到i不一定有边,则aji不一定等于1、
有向图用邻接矩阵更加节省存储空间.因为无向图的邻接矩阵是对称的,所以也就是多用了一些存储空间.

布尔的乘法就是布尔的“且”运算,两个数相乘,都是1时得1,只要有一个是0就得0.布尔的加法是“或”运算,两个数相加,都是0时得0,只要有一个是1就得1.
矩阵的话,就是把普通矩阵的（乘、加）替换成布尔的（乘、加）.

因为拓扑中两个结点只有一个单向边,用邻接表更节省空间,而且在实现拓扑排序时,查找下一个处理的结点,只需查找邻接表指针项为空的结点,查找平均复杂度为O(n)如果用邻接矩阵的话,必须从头开始扫描,平均复杂度为O(n^2)

用来查找当这个定点做起始定点时,那些顶点在我后面.

如果有对称元素 aij 和 aji 分别是1和0,那么一定是有向图(有一条有向边连接两点)
但如果所有的对应元素都相同,就无法判断是有向图还是无向图

运行时间比较长而已 不会死循环 把 k m A三行程序后面加上分号

用C++实现的,希望对你有所帮助.#include #include using namespace std; #define int_max 10000#define inf 9999 #define max 20//…………………………………………邻接矩阵定义……………………typedef struct Arc...

（1）、如图所示.
（2）、深度优先：ABDCE
广度优先：ABEDC

答案应该是 B.5
此题在于理解邻接矩阵的意思：
是 5×5矩阵,说明有5个顶点.aij = 1 意思是第i个顶点与第j个顶点之间有一条边.如 a21 = a21 = 1,说明第1个顶点与第2个顶点之间有一条边.
数总的边数,只需上三角里面的数的和.

说法是对的,因为邻接矩阵第i行表示的是：以i号结点为始点其他结点为终点的路.如i行j列为1,则说明i号结点到j号结点邻接.所以第i行的非∞元素个数的含义是：以i号结点为出发点其他结点为终点的邻接边的条数.这其实就是有向图中顶点i出度的定义.
不理解的话再找我~接受的话记得采纳哦

左下三角都是0,即上三角矩阵.

#include "stdio.h"
#define MAX 50
typedef struct LNode{
int data;
struct LNode *next;
}LNode;
void OutputDegree(int matrix[MAX][MAX], int n);
void Insert(LNode *head, int data);
void list(LNode *head);
void createAdjList(int matrix[MAX][MAX], int n, LNode *head[]);
void main()
{
int matrix1[MAX][MAX] = {{0,1,1},{1,0,1},{0,0,0}};
int matrix2[MAX][MAX] = {{0,1,0,1,0},{1,0,1,0,0},{0,1,0,1,1},{1,0,1,0,0},{0,0,1,0,0}};
int n; /* 顶点数 */
LNode *head[MAX];
int i;

n = 3;
printf("List degree of all vertex : n");
OutputDegree(matrix1, n);

for(i=0; idata = i+1;
}

createAdjList(matrix1, n, head);

printf("Adjancency List : n");
for(i=0; idata);
list(head[i]);
printf("n");
}

n = 5;
printf("List degree of all vertex : n");
OutputDegree(matrix2, n);

for(i=0; idata = i+1;
}

createAdjList(matrix2, n, head);

printf("Adjancency List : n");
for(i=0; idata);
list(head[i]);
printf("n");
}
}
/* 输出顶点的度 */
void OutputDegree(int matrix[MAX][MAX], int n)
{
int InDegree[MAX]; /* 入度 */
int OutDegree[MAX]; /* 出度 */
int i, j;

for(i=0; inext = NULL;

if(pre == NULL)
{
head->next = temp;
return;
}
for(; pre->next!=NULL; pre=pre->next);
pre->next = temp;
}
void list(LNode *head)
{
LNode *curr;
for(curr=head->next; curr!=NULL; curr=curr->next)
{
printf("%dt", curr->data);
}
}
/* 根据邻接矩阵构建邻接表 */
void createAdjList(int matrix[MAX][MAX], int n, LNode *head[])
{
int i, j;

for(i=0; i

(1)图

(2)最小生成树

估计是你的程序有错误的地方,我求出来是一样的

这个其实很好办的,在有向图的基础上,作如下修改.创建有向图的过程中,用一个数来表示是否相连,可以设置weight为1或0.可以在确定一条弧的两个顶点后,locate其位置后将其的权值定为1或0,1表示相连,0表示不相连.这时候赋值的时候写两句,比如说这样：
G->arcs[i][j].adj=weight;
G->arcs[j][i].adj=weight;
其中i,j分别表示所在的行与列.G是一个图,arcs是一个邻接矩阵,adj就是权值,weight是具体的值,为1或0.这里写了两遍的语句就是实现了无向图的创建.其他的程序就可以依此进行修改,这个还是比较简单的,好好写吧.

有n个顶点,就有n的平方个元素,这是邻接矩阵这个数据结构决定的.

删边i-j
邻接矩阵：
有向图：map[i][j] = 0;
无向图：map[i][j] = map[j][i] = 0;
邻接表：
有向图：
p = v[i] -> firstedge；
pre = p;
while (p && p -> data != j)
{pre = p;p = p -> next;}
if (p && pre == p) v[i] -> firstedge = p -> next;
else if (p) pre -> next = p -> next;
无向图：
p = v[i] -> firstedge；
pre = p;
while (p && p -> data != j)
{pre = p;p = p -> next;}
if (p && pre == p) v[i] -> firstedge = p -> next;
else if (p) pre -> next = p -> next;
p = v[j] -> firstedge；
pre = p;
while (p && p -> data != i)
{pre = p;p = p -> next;}
if (p && pre == p) v[j] -> firstedge = p -> next;
else if (p) pre -> next = p -> next;

就是用矩阵的形式表现图中各节点的关系
给你写一个 其他的你可以补充
V5 ---V4------V3
表示对于V5,其后有两个结点与V5有关系.

看图

已知一个无向图G=(V,E),其中V={V1,V2,V3,V4},其邻接矩阵如下 0 1v2 深度遍历序列：v1 - v2 - v3 - v4 对应的生成树包含的边是：e12,

图片上传不了,所以直接传word文档格式了.

（1） 图中有多少条弧
从图中的每个顶点出发,看看边表中的结点数共有多少个
（2） 从顶点i到顶点j是否存在弧
从顶点i出发,扫描边表中是否有顶点是存在即可
（3） 顶点i的入度和出度
顶点i的出度：从顶点i出发,扫描其边表数数一下有多少个结点,出度就是多少
顶点i的入度：扫描所有顶点的边表,看看有多少个顶点编号为i的结点即可

邻接矩阵：
0 0 1 1 0
0 0 0 1 1
1 0 0 0 1
1 1 0 0 0
0 1 1 0 0
邻接表：
A:C->D
B:D->E
C:A->E
D:A->B
E:B->C

0、1和无穷三者不可能同时出现.无向和有向无权图中用1表示能够直接到达,0表示不能一步到达.带权图中正数代表路径权值,无穷表示一步无法到达.

(1)


(2)




3 4 2 2
A*A*A= 1 3 2 4
3 3 3 1
3 4 4 3


v1到v3通路有2条,v4到v2长为3的通路有4条,v1到自身长为3的回路有3条
(3) 强连通,G中的顶点到其他任意的顶点都可达.

入度就是有多少条边指向这个点,出度就是从这个点出发有多少条边,这个不难吧
点 入度 出度
1 2 1
2 2 2
3 1 3
4 3 0
5 2 3
6 1 2
邻接矩阵就是一个二维数组,行列都是顶点,行表示开始,列表示结束,这是一个无权图,如果行到列有指向的边,则用1表示,如果没有,就用0,这个也不难吧
1 2 3 4 5 6
1 0 0 0 1 0 0
2 1 0 1 0 0 0
3 0 0 0 1 1 1
4 0 0 0 0 0 0
5 1 1 0 1 0 0
6 0 0 0 0 1 0
最上和最左的1 2 3 4 5 6是行标和列标,写矩阵的时候就不用写了.然后把剩下的放在一个中括号里面就行了.
入边图示我就不知道是什么了
强连通分量：有向图强连通分量在有向图G中,如果两个顶点vi,vj间（vi>vj）有一条从vi到vj的有向路径,同时还有一条从vj到vi的有向路径,则称两个顶点强连通(strongly
connected).如果有向图G的每两个顶点都强连通,称G是一个强连通图.有向图的极大强连通子图,称为强连通分量
这里强连通分量应该就是去掉顶点1、4以及和顶点1、4相连的边所剩下的子图吧.这个我也有点不确定.

num...
javascript

求出Laplace矩阵的秩就可以了,因为0特征值个个数就是连通分支数.
也可以用类似于最小生成树的算法把所有的连通分支都找出来.

邻接矩阵：
0 1 1 1 0
1 0 1 0 1
1 1 0 1 1
1 0 1 0 1
0 1 1 1 0
邻接表:
1->2->3->4
2->1->3->5
3->1->2->4->5
4->1->3->5
5->2->3->4

算法如下：
设邻接矩阵维度为n*n,将邻接矩阵进行标准化转为概率转移矩阵,方法是每一行元素除以行和保证每行和为1（由于连通,每行和一定大于零,所以除法可实现）
首先判断矩阵对角线上是否有>0的元素,如有证明有欧拉回路（自环）,否则进行下一步
第二步将矩阵平方,判断矩阵对角线上是否有>0的元素,如有证明有欧拉回路（两个节点的环）,否则进行下一步
以此类推,直到计算矩阵的n次方,判断对角线上是否有>0的元素,如有证明有欧拉回路,此时仍没有>0的元素证明该连通图没有欧拉回路
这个方法的依据是,如果将邻接矩阵标准化为概率转移矩阵,那么对矩阵进行k次方,得到的矩阵第(i,j)个元素的意义就是通过k步使得从i走到j的概率,那么对角线(i,i)代表的就是从i经k步回到i的概率,这个概率大于零就代表有一条回路.对于一个共有n个节点的有欧拉回路的连通图,最短的欧拉回路结点个数一定小于等于n,所以如果n次方后还没有出现回路概率就可以判断没有回路了
算法效率类型我不太清楚是怎么算的……不过这个算法方面,标准化矩阵的部分运算复杂度不超过n,之后至多进行n步,每一步的矩阵幂大概可以到O(n)复杂度,判断至多也就是O(n),所以这个复杂度不超过O(n^2)的吧

这个可以先把这些数据读入一个矩阵里面,然后对矩阵进行操作就行了

#include
#include
#include
#include
#define maxsize 64
#define TRUE 1
#define FALSE 0
#define n 10
#define e 13
typedef char datatype ;
typedef char vextype;
typedef int adjtype;
typedef struct
{
vextype vexs[maxsize];
adjtype arcs[maxsize][maxsize];
}graph;
typedef struct
{
datatype data[maxsize];
int front,rear;
}sequeue;
typedef struct node
{
int adjvex;
struct node *next;
}edgenode;
typedef struct
{
vextype vertex;
edgenode *link;
}vexnode;
vexnode gl[maxsize];
graph *ga;
sequeue *Q;
graph *CREATGRAPH()
{
int i,j,k;
char ch;
system("cls");
scanf("%c",&ch);
printf("n请输入顶点信息(邻接矩阵):");
for(i=1;ivexs[i]);
for(i=1;iarcs[j][i]=1;
}
return ga;
}
void PRINT()
{
int i,j;
system("cls");
printf("n对应的邻接矩阵是：nn");
for(i=1;iadjvex=i;
s->next=gl[j].link;
gl[j].link=s;
}
}
void PRINTL()
{
int i;
edgenode *s;
system("cls");
printf("n对应的邻接表是：n");
for(i=1;iadjvex);
s=s->next;
}
printf("n");
}
}
sequeue *SETNULL(sequeue *P)
{
P->front=maxsize-1;
P->rear=maxsize-1;
return P;
}
int EMPTY(sequeue *Q)
{
if(Q->rear==Q->front)
return TRUE;
else
return FALSE;
}
sequeue *ENQUEUE(sequeue *Q,int k)
{
if(Q->front==(Q->rear+1)%maxsize)
{
printf("队列已满!n");
return NULL;
}
else
{
Q->rear=(Q->rear+1)%maxsize;
Q->data[Q->rear]=k;
}
return Q;
}
int DEQUEUE(sequeue *Q)
{
if(EMPTY(Q))
{
printf("队列为空,无法出队!n");
return FALSE;
}
else
{
Q->front=(Q->front+1)%maxsize;
return Q->data[Q->front];
}
return 1;
}
void BFS(int k)
{
int i,j;
int visited[maxsize]={0};
printf("n广度优先遍历后得到的序列是:");
Q=SETNULL(Q);
printf("%3c",ga->vexs[k]);
visited[k]=TRUE;
Q=ENQUEUE(Q,k);
while(!EMPTY(Q))
{
i=DEQUEUE(Q);
for(j=1;jarcs[i][j]==1)&&(!visited[j]))
{
printf("%3c",ga->vexs[j]);
visited[j]=TRUE;
Q=ENQUEUE(Q,j);
}
}
printf("nn深度优先遍历后得到的序列是:");
}
void BFSL(int k)
{
int i;
int visited[maxsize]={0};
edgenode *p;
Q=SETNULL(Q);
printf("n广度优先遍历后得到的序列是:");
printf("%3c",gl[k].vertex);
visited[k]=TRUE;
Q=ENQUEUE(Q,k);
while(!EMPTY(Q))
{
i=DEQUEUE(Q);
p=gl[i].link;
while(p!=NULL)
{
if(!visited[p->adjvex])
{
printf("%3c",gl[p->adjvex].vertex);
visited[p->adjvex]=TRUE;
Q=ENQUEUE(Q,p->adjvex);
}
p=p->next;
}
}
printf("nn深度优先遍历后得到的序列是:");
}
void DFS(int i)
{
int j;
static int visited[maxsize]={0};
printf("%3c",ga->vexs[i]);
visited[i]=TRUE;
for(j=1;jarcs[i][j]==1)&&(!visited[j]))
DFS (j);
}
void DFSL(int k)
{
int j;
edgenode *p;
static int visited[maxsize]={0};
printf("%3c",gl[k].vertex);
visited[k]=TRUE;
p=gl[k].link;
while(p)
{
j=p->adjvex;
if(!visited[j])
DFSL(j);
p=p->next;
}
}
void main()
{
int i,k;
int ch;
Q=malloc(sizeof(graph));
ga=malloc(sizeof(graph));
while(1)
{
printf("nnn");
printf("输入你的选择:");
scanf("%d",&ch);
switch(ch)
{
case 1:CREATADJLIST();
PRINTL();
printf("想从第几号结点开始:");
scanf("%d",&k);
BFSL(k);
DFSL(k);break;
case 2:ga=CREATGRAPH();
PRINT();
printf("想从第几号结点开始:");
scanf("%d",&i);
BFS(i);
DFS(i);break;
case 3:exit (0);
}
}
}

有向图同样构造邻接矩阵P
计算P^2
则u,v对应的位置上的数,就是v和u之间长为2的路径数

天那,问同学吧

(1)出入度
出 入
1 1 2 （有条边没方向,暂定为1-》2）
2 1 3
3 2 1
4 3 1
5 1 2
6 2 3
（2）邻接矩阵
1 2 3 4 5 6
1 0 1 0 0 0 0
2 0 0 0 1 0 0
3 0 1 0 0 0 1
4 0 0 1 0 0 1
5 1 0 0 0 0 0
6 1 1 0 0 1 0

#include"utility.h"
#include"adj_matrix_undir_graph.h"
#include"adj_list_dir_graph.h"
#include"dfs.h"
#include"bfs.h"
int main(void)
{
x09int n,j=0,i=0;
x09int m,e,b=0;
x09char vexs[20],c;
x09char nums[20];
x09cout<<"输入无向图的顶点个数n:"<x09cin>>n;
x09cout<<"输入顶点元素："<x09for(i=0;ix09{
x09x09cout<<"请输入第"<x09x09cin>>vexs[i];
x09x09j++;
x09}
x09
x09cout<<"输出无向图的邻接矩阵："<x09AdjMatrixUndirGraph aundir(vexs,n);
x09for(i=0;ix09{
x09x09for(int v=1;vx09x09{
x09x09x09cout<<"输入Y/N,是否插入边:";
x09x09x09cin>>c;
x09x09x09if(c == 'Y' )
x09x09x09x09aundir.InsertEdge(i,v);
x09x09}
x09}
x09Display(aundir);
x09
x09cout<<"请输入有向图的顶点个数m：";
x09cin>>m;
x09for(int a=0;ax09{
x09x09cout<<"输入第"<x09x09cin>>nums[a];
x09x09b++;
x09}
x09AdjListDirGraph dir(nums,m);
for(int k=0;kx09{
x09x09for(e=0;ex09x09{
x09x09x09cout<<"是否插入边V"<x09 x09cin>>c;
if(c == 'Y' )
x09x09x09x09dir.InsertEdge(k,e);
x09x09}
x09}
x09Display(dir);
x09cout<<"无向图的深度遍历：";
x09DFSTraverse(aundir,Write);
x09cout<x09cout<<"无向图的广度遍历：";
BFSTraverse(aundir,Write);
x09
x09cout<x09cout<<"有向图的深度遍历：";
x09DFSTraverse(dir,Write);
x09cout<x09cout<<"有向图的广度遍历：";
BFSTraverse(dir,Write);

是地信的题吧,先给你说v1怎么求,
先找出v1能去的最近的点,为V2,
如果S1i>S12+S2i
修改V1到Vi的距离为S12+S2i
然后去掉V2,在其余的点中找距V1最近的,按上面的方法修改
最后得到V1与其他各点的最短距离
同样的方法求出到其他点的最短距离

邻接表：
v1: v2 - v3 - v4
v2: v1 - v3 - v4
v3: v1 - v2
v4: v1 - v2
深度遍历序列：v1 - v2 - v3 - v4
对应的生成树包含的边是：e12, e24, e23
广度遍历序列：v1 - v2 - v4 - v3
对应的生成树包含的边是：e12, e14, e23

2倍
因为每条边对应矩阵中的两个1

先根据邻接矩阵把对应的图画出来，然后随便用一种最小生成树算法就行了

设 a-z为1-25
若 A、B合作 则 s[1][2]=1 s[2][1]=1;
否则 二者都为0

这句话不对,邻接表和邻接矩阵,即可以存储无向图也可以存储有向图,稠密图适合用邻接矩阵,稀疏图适合用邻接表存储

无向图是欧拉图的充要条件是每个顶点度数为偶数,
你数邻接矩阵每一行1的个数,如果各行均是偶数,就是欧拉图

在一个图中,所有顶点的度数之和等于图的边数的2倍.2、 对
2.有向图G用邻接矩阵存储,其第i行的所有元素之和等于顶点i的入度.1、 错
3.一棵具有257个结点的完全二叉树,它的深度为9.2、 对
4.二叉树中每个结点的两棵子树是有序的.2、 对
5.为了实现图的遍历,其深度优先搜索算法使用的一个辅助数据结构为() .a、栈
6.二叉树是非线性数据结构,所以().c、顺序存储结构和链式存储结构都能存储
7.排序时扫描待排序记录序列,顺次比较相邻的两个元素的大小,逆序时就交换位置.这是哪种排序方法的基本思想?d、冒泡排序
8.在一个待排序的序列中,只有很少量元素不在自己最终的正确位置上,但离他们的正确位置都不远,则使用()排序方法最好.a、直接插入

A．连通图的生成树是该连通图的一个极小连通子图（最小生成树是极小连通子图，生成树不一定是最小生成树）
B．无向图的邻接矩阵是对称的，有向图的邻接矩阵一定是不对称的 （可能是对称的）
C．任何一个有向图，其全部顶点可以排成一个拓扑序列（存在回路的不能构成拓补排序）
D．有回路的图不能进行拓扑排序（是对的）
答案应该是D

Any graph can be expressed by a matrix (adjacency matrix, Laplace matrix), and its structure and properties can be studied through the eigenvalue (graph spectrum) of the matrix. This paper mainly discusses the spectral problems of the no cutting edge connected graph with fixed cutting points. By using graft transformation, and basing on the property traits of no cutting edge connected graph and the variable law of the adjacency matrix’s optimum eigenvalue, this paper comes out with a spectral radius’ biggest extreme graph of no cutting edge connected graph with a fixed cutting points of not more than 2.
【英语牛人团】