图 、最小生成树

一、图

（一）什么是图？
  

表示“”多对多“关系；

包含：一组顶点：通常用V（Vertex）表示顶点集合；

           一组边：通常用E(Edge)表示边的集合。

（二）抽象数据类型定义

抽象名称：图（Graph）；

数据对象集：G（V,E）由一个非空的有限顶点集合V和一个有限边集合E组成。

---

操作集：Graph Create():建立并返回空图

              Graph InsertVertex（Graph G,Vertex v）：将v插入G;

              Graph InsertEdge（Graph G,Edge e）：将e插入G;

              void DFS（Graph G ， Vertex v）： 从顶点v出发深度优先遍历图G;

              void BFS(Graph G ， Vertex v)： 从顶点v出发宽度优先遍历图G;

              void ShortestPath（Graph G , Vertex V , int Dist[]）:计算图G中顶点v到其他任意顶点的最短距离。

              void MST（Graph G）：计算图G的最小生成树。 

（三）怎么在程序中表示一个图

        1.邻接矩阵G[N][N]:N个顶点从0——N-1编号

        存在问题：对于无向图的存储，怎样可以省略一半的空间。

        解决：用一个长度为N（N+1）/2的一维数组A存储{G00,G10,G11,.......，Gn-1 n-1}，则Gij在A中对应的下标为：i（i+1）/2+j ，对于网络只需将G[i][j]的值定义为边<Vi,Vj>的权重即可。

邻接矩阵——有什么好处？
        直观、简单、好理解；

方便计算任一顶点的“度”（从该顶点发出的边数叫“出度”，指向该顶点的边叫“出度”）

不足：浪费空间——存稀疏图（点很多而边很少），有大量的无效元素。

        2.邻接表：G[[N]为指针数组，对应矩阵每行一个链表，只存非0元素。

（四）图的遍历

（1）DFS 深度优先搜索

访问完所有结点的灯以后，一定是原路返回。对应的是一种堆栈。

void DFS(Vertex V)
{ visited [V] = true;
  for(V的每一个邻接点w)
    if（ ！ visited [W]）
        DFS(W);
}//类似于树的先序遍历

若有N个顶点，E条边，时间复杂度为：

        用邻接表存储图，有0(N+E)

        用邻接矩阵存储图，有O(N的平方)

（2）BFS广度优先搜索

类似于树的层序遍历（树是一种特殊的图）

void BFS( Vertex V)
{
    visited[V] = true;
    Enqueue(V , Q);
    while( !IsEmpty(Q)){
        V = Dequeue(Q);
        for(V的每一个邻接点){
            if（ ！visited[W]）{
                visited[w] = true;
                Enqueue(W , Q);
            }
        }

    }
    
}

二、最小生成树问题

（一）什么是最小生成树

是一颗树：无回路，|v|的顶点一定有|v|-1个边

是生成树：包含全部顶点，|v|-1个边都在图里。

向生成树里任加一条边都一定构成回路

边的权值最小

（二）贪心算法

什么是“贪”：每一步都要最好的

什么是“好”：权重最小的边

需要约束：只能用图里面的边

                只能正好用掉|v|-1个边

                不能有回路

(三)“六度空间”问题

对每个结点，进行广度优先搜索。

搜索过程中累计访问的结点树。

需要记录“层”树，仅记录6层以内的结点树。

 (四)小白专场

1、邻接矩阵表示的图结点的结构

G[i][j] = {1(若<Vi,Vj>是G中的边)，0（否则）}

//初始化顶点
typedef struct Gnode *PtrToGNode;
struct Gnode{
    int Nv;  //顶点数    
    int Ne;  //边数
    WeightType G[MaxVertexNum] [MaxVertexNum];
};
typedef PtrToGNode MGraph;



//插入顶点
typedef int Vertex; //用顶点下标表示顶点，为整型
MGraph CreateGraph (int VertevNum)
{
    Vertex V,W;
    MGraph Graph;
    Graph = (MGraph)malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0
    /*注意：这里默认顶点编号从0开始，到Graph->Nv-1*/
    for(V = 0;V < Graph->Nv;V++)
        for(W = 0;W < Graph->Nv;W++)
            Graph->G[V][W] = 0;
    return Graph;
}


//插入边
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1,V2;   //有向边<V1,V2>
    WeightType Weight;   //权重 
};
typedef PtrToGNode Edge;

void InsertEdge (MGraph Graph,Edge E)
{
    //插入边<V1,V2>
    Graph->G[E->V1][E->V2] = E->Weight;
    //若是无向图，还要插入边<V2,V1>
    Graph->G[E->V2][E->V1] = E->Weight;
}




//创建一个MGraph

MGraph BuildGraph
{    MGraph Graph;


    scanf("%d",&Nv);
    Graph = CreateGraph(Nv);
    scanf("%d",&Graph->Ne);
    if(Graph->Ne != 0){
        E = (Edge)malloc(sizeof(struct ENode));
        for(i = 0;i<Graph->Ne;i==){
            scanf("%d %d %d",%E->V1,&E->V2,&E->Weight);
            InsertEdge(Graph,E);
         }
    }

    //如果顶点有数据的话，读入数据
    for(V=0;V<Graph_>Nv;V++){
        scanf("%C",&Graph->Data[V]);
    }

return Graph;
}

 2.用邻接表表示图

邻接表：G[N]为指针数组，对应矩阵每行一个链表，只存非0元素。san

typedef struct Vnode{
    PtrToAdjVNode FirstEdge;  //定义一个指向第一条边的结点的指针，边结点指针类型PtrToAdjVNode
    //DataType Data;//如果要存顶点的数据的话
}AdjList[MaxVertexNum];


//定义表指针
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  //顶点数
    int Ne;  //边数
    AdjList G;//邻接表
};
typedef PtrToGNode LGraph;  //相当于重新取了一个名字（以邻近表方式存储的图类型）


typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode{
    Vertex AdiV;   //邻接点下标
    WeightType Weight;  //边权重
    PtrToAdjVNode Next;
};




//图的初始化
typedef int Vertex; //用顶点下标表示顶点，为整型
LGraph CreateGraph (int VertevNum)
{
    Vertex V,W;
    LGraph Graph;
    Graph = (LGraph)malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0
    for(V = 0;V < Graph->Nv;V++)
         Graph->G[V].FirstEdge = NULL;
    return Graph;
}

//向LGraph中插入一条边
void InsertEdge (LGraph Graph,Edge E)
{    PtrToAdjVNode NewNode;
   //插入边<V1,V2>
//为V2建立新的邻接点
NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdJVNode));
NewNode->AdjV = E->V2;
NewNode->Weight = E->Weight;
//将V2插入V1的表头
NewNode->Next = Graph->G[E->V1].FirstEdge;
G[E->V1].FirstEdge = NewNode;
    //若是无向图，还要加入<V2,V1>

NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdJVNode));
NewNode->AdjV = E->V1;
NewNode->Weight = E->Weight;
//将V1插入V2的表头
NewNode->Next = Graph->G[E->V2].FirstEdge;
G[E->V2].FirstEdge = NewNode;

}