数据结构图论学习总结2

邻接表：

struct EdgeNode//定义边表节点
{
	int adjvex;//临接点域
	EdgeNode *next;
};
template<typename DataType>
struct VertexNode//定义顶点表节点
{
	DataType vertex;
	EdgeNode *firstEdge;
};

具体实现过程；

template <class T>
ALGraph::ALGraph(T a[ ], int n, int e)
{   
    vertexNum=n; arcNum=e; 
    for (i=0; i<vertexNum; i++)   
    {
       adjlist[i].vertex=a[i];
       adjlist[i].firstedge=NULL;      
    } 
     for (k=0; k<arcNum; k++)   
     {
         cin>>i>>j;    
         s=new ArcNode; s->adjvex=j;  //单链表的头插方法	        
         s->next=adjlist[i].firstedge;    
         adjlist[i].firstedge=s;
     }
}

边集数组：

Struct edge
{ 
    int i；
    int j;
    int weight;
}

一条边连接两个点；
算法问题：
1.最小生成树
prim算法

void MinEdge(int lowcast[],int vertexNum)
{
	int k;
	int Min=9999;
	for(int i=1;i<=vertexNum;i++)
	{
		if(lowcast[i]!=0&&lowcast<Min)
		{
			Min=lowcast[i];
			k=I;
		}
	}
	return k;
}
Void prime(int v){
    for(int i=1;i<vertexNum;i++){
        lowcost[i]=edge[0][i];  adjvex[i]=0;
    }
    lowcost[0]=0;
    for(i=1;i<vertexNum;i+++){
        k=MinEdge(lowcost,vertexNum)
        cout<<K<<adjvex[k]<<lowcost[k];
        lowcost[k]=0;
             for(j=1;j<vertexNum;j++)
          if((edge[k][j]<lowcost[j]){
              lowcost[j]=edge[k][j];
              adjvex[j]=k;
           }
    }
}

2.Kruskal算法
算法用了合并集的方法就是将两个不相关合起来；

struct Edge
{
    int weight;
    int from;
    int to;
}edge[MaxSize];
void Kruskal()
{
    int num=0,i,vex1,vex2;
    int parent[VertexNum];
    for(int i=0;i<vertexNum;i++)
    {
        parent[i]=-1;
    }
    for(num=0;i=0;num<vertexNum-1;i++)
    {
        vex1=FindRoot(parent,edge[i].from);
        vex2=FindRoot(parent,edge[i].to);
        if(vex1!=vex2){
            cout<<'('<<edge[i].from<<','<<edge[i].to<<')'<<edge[i].weight;
            parent[vex2]=vex1;
            num++;
        }
    }
}
int FindRoot(int parent[],int v)
{
    int t=v;
    while(parent[t]>-1)
    {
        t=parent[t];
    }
    return t;
}

2.最短路径算法
dijkstra算法

const int MAX=1000;
void  Dijkstra(MGraph g, int v){
       for ( i =0; i<g.vexnum ; i++){
	 dist[i]=g.arcs[v][i];  
               if ( dist[i]!= MAX) 
                      path [i]=g.vertex[v]+g.vertex[i];
               else
                      path[i]=“”;
       }
       S[0]=g.vertex[v]; 
       num=1;  
    While (num<g.vextexNum){
    k=0;
    for(i=0;i<G.vertexNum;i++)
           if((dist[i]<dist[k])   k=i
    cout<<dist[k]<<path[k];
    s[num++]=G.vertex[k];                
    for(i=0;i<G.vertexNum;i++)
             if(dist[k]+g.arc[k][i]<dist[i] {
		 dist[i]=dist[k]+g.arc[k][i];
                       path[i]=path[k]+g.vertex[i];
               }
}
}

Floyd算法

void Floyd(MGraph G)
{
    for (i=0; i<G.vertexNum; i++)        
       for (j=0; j<G.vertexNum; j++)
       {
          dist[i][j]=G.arc[i][j];
          if (dist[i][j]!=∞) 
               path[i][j]=G.vertex[i]+G.vertex[j];
          else path[i][j]=""; 
       }
     for (k=0; k<G.vertexNum; k++)         
        for (i=0; i<G.vertexNum; i++)       
           for (j=0; j<G.vertexNum; j++)
               if (dist[i][k]+dist[k][j]<dist[i][j]) {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    path[i][j]=path[i][k]+path[k][j];
              }
}

Aov网与拓扑排序
AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。

void TOpSort(){
int  top=-1, count=0;
for(int i=0;i<vertexnum;i++)
     if(adjlist[i].in==0) s[++top]=i;
while(top!=-1){
    j=s[top--]; cout <<adjlist[j].vertext;   count++;
    p=adjlist[j].firstedge;
    while(p!=NULL){
          k=p->adjvex; adjlist[k].in--;
         if(adjlist[k].in==0) s[top++]=k;
         p=p->next;
      } 
}
If (count<vertexNum) cout<<“有回路”；
}

删除所有入度为0的点如果最后还存在边，说明最后是有回路的。

关键路径
AOE网络：
在一个表示工程的带权有向图中，
用顶点表示事件，
用有向边表示活动，
边上的权值表示活动的持续时间，
称这样的有向图叫做边表示活动的网，简称AOE网。
AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。
现在还不太理解后续会总结