图（2021.7.19）

考研
努力努力再努力
**
1.将邻接表转换为邻接矩阵

void convert(ALGraph &G,int arcs[M][N]){
	for(i=0;i<n;i++){
		p=(G->v[i]).firstarc;
		while(p){
			arcs[i][p->data]=1;
			p=p->nextarc;
		}
	}
}

2.求无向图是否为树

思想：利用深度优先算法，遍历所有结点，若一次遍历就可访问n个结点和n-1条边，则是一个树
bool istree(Graph &G){
	for(i=1;i<=G.vexnum;i++)
		visited[i]=false;
	int vnum=0,enum=0;
	DFS(G,1,vnum,enum,visited);
	if(vnum==G.vexnum&&enum==2*(G.vexnum-1))
		return true;
	else return false;
}
void DFS(Graph G,int v,int vnum,int enum,int visited[]){
	visited[v]=true;
	vnum++;
	int w=firstneighbour(G,v);
	while(w!=-1){
		enum++;				//只要有邻接点就加一，所以每条边算了两次
		if(!visited[w])
		DFS(G,w,vnum,enum,visited);
		w=nextneighbour(G,v,w);
	)
}

3.DFS的非递归算法

void dfsnonrc(ALGraph &G,int v){
	int w;
	InitStack(s);
	for(i=0;i<G.vexnum;i++)
		visited[i]=false;
	Push(s,v);				//从顶点v开始遍历
	visited[v]=true;
	while(!isEmpty(s)){
		Pop(s,k);
		visit(k);
		for(w=firstneighbour(G,k);w>=0;w=nextneighbour(G,k,w))
			if(!visited[w]){
				Push(s,p);
				visited[w]=true;
			}
	}
}

4.两种遍历看是否存在路径

深度优先遍历（递归）
void DFS(Graph G,int i,int j,bool &canreach){
	if(i==j){
		canreach=true;
		return;
	}
	visited[i]=1;
	for(p=firstneighbour(G,i);p>=0;p=nextneighbour(G,i,p))
		if(!visited[p]&&!canreach)
			DFS(G,p,j,canreach);
}

广度优先遍历（队列）
int BFS(Graph G,int i,int j){
	EnQueue(Q,i);
	while(!isEmpty(Q)){
		DeQueue(Q,k);
		visited[k]=1;
		if(k==j)	return 1;
		for(p=firstneighbour(G,k);p>=0;p=nextneighbour(G,k,p)){
			if(p==j)
				return 1;
			if(!visited[p]){
				EnQueue(Q,p);
				visited[p]=1;
			}
		}
	}
	return 0;
}

5.输出两顶点所有简单路径

void Findpath(Graph *G,int u,int v,int path[],int d){		//初始d=-1
	path[++d]=u;
	visited[u]=1;
	if(u==v)
		print(path[]);
	p=G->adjlist[u].firstarc;
	while(p){
		w=p->adjvex;
		if(!visited[w])
			Findpath(G,w,v,path,d);
		p=p->nextarc;
	}
	visited[u]=0;
}

6.DFS实现拓扑排序

void dfst(Graph G){
	for(i=0;i<G.vexnum;i++)
		visited[i]=false;
	time=0;
	for(i=0;i<G.vexnum;i++)
		if(!visited[i])
			dfs(G,i);
}
void dfs(Graph G,int i){
	visited[i]=true;
	for(w=firstneighour(G,i);w>=0;w=nextneighbour(G,i,w))
		if(!visited[w])
			dfs(G,w);
	time=time+1;
	finishtime[i]=time;
}

7.利用Dijkstra给出的生成树不是最小生成树
详细解释

	int min[n]={inf};  
	//表示从start出发到各点的最短路径或者加入生成树的最小权值边
	closed[start]=true;			//假设从start开始
	min[start]=0;
	for(i=1;i<n;i++){			//连接剩下n-1个点
		int k=-1;				//保存结点
		for(j=0;j<n;j++)
			if(!closed[j]&&(k==-1||min[j]<min[k]))
				k=j;
		closed[k]=true;
		//Dijkstra
		for(j=0;j<n;j++)
			if(min[j]>min[k]+G[k][j])
				min[j]=min[k]+G[k][j];
		//Prim
		for(j=0;j<n;j++)
			if(min[j]>G[k][j])
				min[j]=G[k][j];
	}

8.结构

typedef struct{
	unsigned int ip;
	unsigned int id;
}linknode;
typedef struct{
	unsigned int prefix;
	unsigned int mask;
}netnode;
typedef struct node{
	int flag;
	union{
		linknode node;
		netnode node;
	}linkornet;
	unsigned int metric;
	struct node *next;
}arcnode;
typedef struct hnode{
	unsigned int routerid;
	arcnode *ln_link;
	struct hnode *next;
}Hnode;