第十九次-图(四)

邻接表
邻接表存储的基本思想：
对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）
所有边表的头指针和存储顶点信息的一维数组构成了顶点表。

定义邻接表的结点：

struct ArcNode{   
      int adjvex; 
      ArcNode *next;
};
template <class T>
struct VertexNode{
      T vertex;
      ArcNode *firstedge;
};

邻接表存储有向图的类

const int MaxSize=10;    //图的最大顶点数
template <class T>
class ALGraph
{    
   public:
       ALGraph(T a[ ], int n, int e);   
       ~ALGraph;    
       void DFSTraverse(int v);      
       void BFSTraverse(int v);      
   ………
  private:
       VertexNode adjlist[MaxSize];   
       int vertexNum, arcNum;       
};

数 ：

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;
     }
}

深度优先遍历：

template <class T>
void ALGraph::DFSTraverse(int v){        
    cout<<adjlist[v].vertex;  visited[v]=1;
    p=adjlist[v].firstedge;    
    while (p!=NULL)     {
        j=p->adjvex;
        if (visited[j]==0) DFSTraverse(j);
    p=p->next;           
    }

广度优先遍历：

template <class T>
void ALGraph::BFSTraverse(int v){
   front=rear=-1;   
   cout<<adjlist[v].vertex;    visited[v]=1;   Q[++rear]=v;   
   while (front!=rear)  {
       v=Q[++front];    p=adjlist[v].firstedge;    
       while (p!=NULL)  {
            j= p->adjvex;
            if (visited[j]==0) {
                cout<<adjlist[j].vertex;  visited[j]=1; Q[++rear]=j;
            }
            p=p->next;
       }
    }
}

---

增删顶点
增加：顶点表中插入一个元素
删除：在顶点表中删除一个元素，同时在边表中删除相应的边
增删边<x, y>
如果是有向图，则在x的边表中增加/删除边；
如果是无向图，则还要在y的边表中增加/删除一条边

图的存储结构
邻接矩阵
有向图和无向图
邻接表 有向图
（出边表）和无向图
逆邻接表（有向图的入边表）
有向图，方便计算顶点的入度
有向图的十字链表
无向图的邻接多重表
边集数组
十字链表：有向图的链式存储结构

边集数组：
利用两个一维数组
一个数组存储顶点信息，
另外一个数组存储边及其权
数组分量包含三个域：边所依附的两个顶点，权值
各边在数组中的次序可以任意。
边集数组的实现：

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

将邻接矩阵转化成边集数组：

edge edges[M];//边的数据结构类型的变量
 for ( i = 0; i < G->vexnum; i++) { 
  for (j = 0; j <= G->vexnum; j++)  {
     if (G->arc[i][j] == 1)   {
        edges[k].begin = i;
          edges[k].end = j;
           // edges[k].weight = G->arc[i][j];
               k++;
         }
     }
 }

最小生成树：
生成树的代价：设G=（V，E）是一个无向连通网，生成树上各边的权值之和称为该生成树的代价。
最小生成树：在图G所有生成树中，代价最小的生成树称为最小生成树。
理解
//与离散数学中的表示相同 但需要转化为代码让计算机得到指令
MST（ minimum spanning tree）性质：
假设G=(V, E)是一个无向连通网，U是顶点集V的一个非空子集。若(u, v)是一条具有最小权值的边，其中u∈U，v∈V－U，则必存在一棵包含边(u, v)的最小生成树。
MST性质的应用：
构造最小代价生成树
两种方法：
Prime法：加点法
Kruskal方法：加边法
普里姆（Prim）算法：
基本思想：
设G=(V, E)是具有n个顶点的连通网，
T=(U, TE)是G的最小生成树，
T的初始状态为U={u0}（u0∈V），TE={ }，
重复执行下述操作：
在所有u∈U，v∈V-U的边中找一条代价最小的边(u, v)并入集合TE，同时v并入U，直至U=V。

数据结构设计
数组lowcost[n]：用来保存集合V-U中各顶点与集合U中顶点最短边的权值，lowcost[v]=0表示顶点v已加入最小生成树中；
数组adjvex[n]：用来保存该边所依附的（集合V-U中各顶点与集合U中顶点的最短边）集合U中的顶点。