算法篇----图

1. 编写算法，根据用户输入的偶对（以输入0表示结束）建立有向图邻接表（设有n个顶点）（19年）

	typedef struct ArcNode(   //边表结点
		int adjvex;  //该弧所指向的顶点位置
		struct ArcNode *next;  //指向下一条弧的指针
	)ArcNode;
	typedef struct VNode(
		VertexType vertex;  //顶点信息
		ArcNode *firstarc;   //指向第一条依附该顶点的弧的指针
	)VNode,Adjlist[maxvertexnum];
	typedef struct {
		Adjlist vertices;  //邻接表
		int vexnum,arcnum;    //图的顶点数和弧数
	}ALGraph;
	void CreateAdjlist(ALGraph &g){
		int i,j,k;
		ArcNode *s;
		for(k=0;k<n;k++){
			g[k].vertex=k;
			g[k].firstarc=null;
		}   //输入顶点信息,建立顶点向量
		scanf("%d,%d",&i,&j);
		while(i!=0 && j!=0){
			s=(ArcNode *)malloc(sizeof(ArcNode));
			s->adjvex=j;
			s->next=g[i].firstarc;
			g[i].firstarc=s;  //将边结点链入
			scanf("%d,%d",&i,&j);
		}
	}

2. 已知n个顶点带权图用邻接矩阵表示，试编写算法实现用kruskal算法构造最小生成树，求最小权值。（17年）

	typedef struct road  *Road;
	typedef struct road{
		int a,b;  //a,b为边的两个顶点，w为边的权值
		int weight;
	}road;
	typedef struct MGraph *Graph;
 	typedef struct {
 		/*VertexType Ver[maxvertypenum];  //顶点表
  		EdgeType Edge[maxvertexnum][maxvertexnum];  //邻接矩阵，边表*/
  		int vexnum,arcnum; //当前顶点数和弧数
  		Road data;
 	}MGraph;
	int Kruskal(Graph g){
		int sum=0;
		int V[max];
		for(int i=0;i<g->arcnum;i++)
			v[i]=i;
		sort(g->data,g->vernum);   //按照权值从小到大排序
		for(i=0;i<g->vernum;i++){
			int c,d;
			c=getRoot(v,g->data[i].a);  //v为并查集，x为待查顶点
			d=getRoot(v,g->data[i].b);
			if(c!=d){
				v[c]=d;
				sum+=g->data[i].weight;
			}
		}
		return sum;
	}

3. 设计算法，求不带权无向连通图G中距离顶点v的最远顶点（15年）

	int Maxdist(Graph *G,int v){
		ArcNode *p;
		int Qu[maxsize];
		int front=0,rear=0;
		int i,j,k;
		for(i=0;i<G->arcnum;i++)
			visited[i]=1;
		Qu[rear++]=v;
		visited[v]=1;
		while(front!=rear){
			front=((front+1)%maxsize);
			k=Qu[front];  //顶点k出队
			p=G->adjlist[k].firstarc;
			while(p!=null){
				j=p->adjvex;
				if(visited[j]==0){
					visited[j]=1;
					rear=(rear+1)%maxsize;
					Qu[rear]=j;
				}
				p=p->next;
			}
		}
		return k;
	}

4. 给定带权有向图G和源点V0，设计V0到其余顶点的最短路径（14年）

	void ShortPath(MGraph G,int v0,Pathmatrix &p,shortpath &D){
		//用dijistra算法求有向图G的v0顶点到其余顶点v的最短路径p[v]及其带权长度D[v]
		//若p[v][w]为true，则w是从v0到v最短路径上的顶点，final[v]最短路径
		for(int v=0;v<G.vernum;++v){
			final[v]=false;
			D[v]=G.arctices[v0][v];
			for(int w=0;w<G.vernum;++w)
				p[v][w]=false;  //设空路径
			if(D[v]<infinity){
				p[v][v0]=true;
				p[v][v]=true;
			}
		}
		D[v0]=0;
		final[v0]=true;
		//开始主循环，每次求得v0到某个顶点的最短路径，并加入到s集
		for(int i=1;i<G.vernum;++i){
			min=infinity;
			for(w=0;w<G.vernum;++w){
				if(!final[w] && D[w]<min){
					v=w;
					min=D[w];
				}
			final[v]=true;
			for(w=0;w<G.vernum;++w){
				if(!final[w] && min+G.arctices<D[w])){
					D[w]=min+G.arctices[v][w];
					p[w]=p[v];
					p[w][v]=true;
				}
			}
		}
	}

5. 设计AOV图拓扑排序的算法（13年）

	Status ToplogicalSort(ALGragh G){
		//有向图G采用邻接表存储结构
		FindInDegree(G,indegree); //对各顶点求入度
		InitStack(s);
		for(int i=0;i<G.vexnum;++i){
			if(!indegree[i])
				push(s,i);
		}
		int count=0;
		while(!StackEmpty(s)){
			pop(s,i);
			printf("%d,%d",i,G.vexnum[i].data);
			++count;
			for(p=G.vertices[i].firstarc;p;p->p->nextarc){	
			k=p->adjvex;
			if(!(--indegree[k]))
				push(s,k);     //若入度为0，则入栈
			}
		}
		if(count<G.vexnum)
			return error;
		else
			return ok;
	}

6. 图的深度优先遍历算法（15年）

	Boolean visited[Max];
	Status (*VisitFunc)(int v);  //访问函数变量
	void DFStraverse(Gragh G,Status(*visit)(int v)){
		vistFunc=visit;
		for(v=0;v<G.vernum;++v)
			visited[v]=false;
		for(v=0;v<G.vernum;++v)
			if(!visited[v])  DFS(G,v);
	}
	void DFS(Gragh G,int v){
		visited[v]=true;
		VisitFunc(V);
		for(w=FirstAdjvex(G,v);w>=0;w=NextAdjvex(G,v,w))
			if(!visited[w])  
				DFS(G,w);
	}	

7. 图的广度遍历算法（14年）

	void BSTraverse(Gragh G,Status(*visit)(int v)){
		initQueue(q);
		for(v=0;v<G.vernum;++v)
			if(!visited[v]){
				visited[v]=true;
				visit(v);
				Enqueue(Q,v);
				while(!QueueEmpty(Q)){	
					Dequeue(Q,v);
					for(w=FirstAdj	vex(G,u);w>=0;w=NextAdjvex(G,u,w))
						if(!visited[w]){
							visited[w]=true;
							visit(w);
							Enqueue(Q,w);
						}
				}
			}
	}