数据结构第六章小结————图

一、图的概念

（1）图的定义：

• 图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V，E），其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。注意：线性表中可以没有元素，称为空表。树中可以没有结点，叫做空树。但是在图中不允许没有顶点，可以没有边。

（2）图的基本术语：

• 无向边：若顶点Vi和Vj之间的边没有方向，称这条边为无向边，用 （Vi，Vj）来表示。
• 无向图：图中任意两个顶点的边都是无向边。
• 有向边：若从顶点Vi到Vj的边有方向，称这条边为有向边，也称为弧，用 <Vi, Vj> 来表示，其中 Vi 称为弧尾，Vj 称为弧头。
• 有向图：图中任意两个顶点的边都是有向边。
• 简单图：不存在自环（顶点到其自身的边）和重边（完全相同的边）的图。
• 稀疏图；有很少条边或弧的图称为稀疏图，反之称为稠密图。
• 权：表示从图中一个顶点到另一个顶点的距离或时间。
• 网：带有权重的图。
• 度：与特定顶点相连接的边数。
• 出度、入度：有向图中的概念，出度表示以此顶点为起点的边的数目，入度表示以此顶点为终点的边的数目。
• 连通图：任意两个顶点都相互连通的图。
• 极大连通子图：包含竟可能多的顶点（必须是连通的），即找不到另外一个顶点，使得此顶点能够连接到此极大连通子图的任意一个顶点。
• 连通分量：极大连通子图的数量。
• 强连通图：此为有向图的概念，表示任意两个顶点v1，v2，使得v1能够连接到v2，v2也能连接到v1 的图。
• 连通图的生成树：一个极小连通子图，它含有原图中全部定点，但只有足以构成一棵树的 n-1 条变，这样的连通子图称为连通图的生成树。
• 最小生成树：此生成树的边的权重之和是所有生成树中最小的。

（3）图的遍历方式

• 深度优先遍历（DFS）：（递归思想）

首先从图中某个顶点v0出发，访问此顶点，然后依次从v相邻的顶点出发深度优先遍历，直至图中所有与v路径相通的顶点都被访问了；若此时尚有顶点未被访问，则从中选一个顶点作为起始点，重复上述过程，直到所有的顶点都被访问完。

//DFS算法大概思想
void dfs()//参数用来表示点的状态  
{  
    if(到达终点状态)  
    {  
        ...//添加未访问的点  
        return;  
    }  
    if(越界或者是不合法)  
        return;  
    if(特殊状态)//剪枝
        return ;
    for(扩展方式)  
    {  
        if(扩展方式所达到状态合法)  
        {  
            修改操作;//添加  
            标记；  
            dfs（）；  
            (还原标记)；  
            //是否还原标记根据题意  
            //如果加上（还原标记）就是 回溯法  
        }  
 
    }  
}  
简易DFS算法思路

 广度优先遍历（BFS）：（使用队列作为辅助结构，当队列不为空时循环）


 首先，从图的某个顶点v0出发，访问了v0之后，依次访问与v0相邻的未被访问的顶点，然后分别从这些顶点出发，广度优先遍历，直至所有的顶点都被访问完。
https://blog.csdn.net/weixin_40953222/article/details/80544928（关于DFS和BFS两种算法的入门解析）
二、图的两种存储结构
 （1）邻接矩阵

图的邻接矩阵的存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（称邻接矩阵）存储图中的边或弧的信息。

    用一个一维数组存放顶点的元素信息     用一个二维数组存储顶点之间的关系，其中的数据元素A[i][j] = 1,i到j有弧且i≠j,否则A[i][j]= 0


struct VerType{
    
    int no;//顶点的编号 
    char info;//顶点的其他信息 
    
};
struct MGraph{
    
    int n,e;//结点数目与边数
    int edges[maxn][maxn];//邻接矩阵的定义 
    int VerType[maxn]; //存放结点的信息
    
};

邻接矩阵的定义

   有向图

 无向图

 无向图的邻接矩阵是对称矩阵

网的邻接矩阵：
A[i][j] = w[i][j] 若<vi,vj>或(vi,vj)∈E ，否则为∞

优点： 易判定任两个顶点之间是否有边或弧存在，适合存储有向图，无向图，有向网，无向网
缺点： 在边稀疏时，浪费存储空间

 （2）邻接表

• 图的链式存储结构，适用于有向图和无向图，对图中每个顶点建立一个单链表，单链表中的结点表示依附于该顶点的边

struct ArcNode{
    int adjvex;//这条边所指向的结点信息
    struct ArcNode *nextarc;//该顶点指向下一条边的指针
    int info;//这条边的相关信息如权值 
}; 
struct VNode {
    char data;//顶点信息 
    ArcNode *firstarc;//指向第一条边的指针 
};
struct Agraph{
    
    VNode adjlist[maxn];//邻接表 
    int n,e;//顶点数目和边数 
};

邻接表定义

•   有向图： 
• 表结点（链式结构存储）：                                                                     
  

adjvex:指示与vi邻接的顶点在图中的位置      

nextarc:指示下一条边或弧的结点                                                              

info:存储和边或弧有关的信息(如权值)

• 头结点（顺序结构存储）：

data:存储顶点名称和其他相关信息

firstarc:指向链表中第一个结点

• vi的出度 = 第i个单链表中的结点数目
• vi的入度 = 遍历整个邻接表中其邻接点值域为i的结点个数

•  无向图：

          若无向图有v个顶点，w条边，则它的邻接表需要v个头结点和2w个表结点（边稀疏时比邻接矩阵省空间）

 https://blog.csdn.net/zhembrace/article/details/72625413 （图的几种存储方式的代码描述）  

https://blog.csdn.net/saltedFishGong/article/details/78764901（基本两种存储结构的理解）

https://blog.csdn.net/JYL1159131237/article/details/78504961  （两种存储结构的转换）

三、最小生成树（贪心算法）

（1）概念：图的生成树是它的一棵含有所有顶点的无环连通子图。一棵加权图的最小生成树是它的一棵权值（所有边的权值之和）最小的生成树。

（2）两种算法：

普里姆算法（Prim）

从顶点0开始，首先将顶点0加入到树中（标记），顶点0和其它点的横切边（这里即为顶点0的邻接边）加入优先队列，将权值最小的横切边出队，加入生成树中。此时相当于也向树中添加了一个顶点2，接着将集合（顶点1，2组成）和另一个集合（除1,2的顶点组成）间的横切边加入到优先队列中，如此这般，直到队列为空。

//进行prim算法实现，使用的邻接矩阵的方法实现。
void Prim(Graph g,int begin) {
 //close_edge这个数组记录到达某个顶点的各个边中的权重最大的那个边
  Assis_array *close_edge=new Assis_array[g.vexnum];

    int j;

    //进行close_edge的初始化，更加开始起点进行初始化
    for (j = 0; j < g.vexnum; j++) {
        if (j != begin - 1) {
            close_edge[j].start = begin-1;
            close_edge[j].end = j;
            close_edge[j].weight = g.arc[begin - 1][j];
        }
    }
    //把起点的close_edge中的值设置为-1，代表已经加入到集合U了
    close_edge[begin - 1].weight = -1;
    //访问剩下的顶点，并加入依次加入到集合U
    for (j = 1; j < g.vexnum; j++) {

        int min = INT_MAX;
        int k;
        int index;
        //寻找数组close_edge中权重最小的那个边
        for (k = 0; k < g.vexnum; k++) {
            if (close_edge[k].weight != -1) {  
                if (close_edge[k].weight < min) {
                    min = close_edge[k].weight;
                    index = k;
                }
            }
        }
        //将权重最小的那条边的终点也加入到集合U
        close_edge[index].weight = -1;
        //输出对应的边的信息
        cout << g.information[close_edge[index].start] 
                <<"   "
                << g.information[close_edge[index].end]
                << "   "
                <<g.arc[close_edge[index].start][close_edge[index].end]
                <<endl;

        //更新我们的close_edge数组。
        for (k = 0; k < g.vexnum; k++) {
            if (g.arc[close_edge[index].end][k] <close_edge[k].weight) {
                close_edge[k].weight = g.arc[close_edge[index].end][k];
                close_edge[k].start = close_edge[index].end;
                close_edge[k].end = k;
            }
        }
    }
}

Prim

克鲁斯卡尔算法（Kruskal）

按照边的权重顺序来生成最小生成树，首先将图中所有边加入优先队列，将权重最小的边出队加入最小生成树，保证加入的边不与已经加入的边形成环，直到树中有V-1到边为止。

//克鲁斯卡算法的实现
void Kruskal() {
    int Vexnum = 0;
    int edge = 0;
    while (!check(Vexnum, edge)) {
        cout << "图的顶点数和边数不合法，重新输入：" << endl;
        cin >> Vexnum >> edge;
    }

    //声明一个边集数组
    Edge * edge_tag;
    //输入每条边的信息
    createGraph(edge_tag, Vexnum, edge);

    int * parent = new int[Vexnum]; //记录每个顶点所在子树的根节点下标
    int * child = new int[Vexnum]; //记录每个顶点为根节点时，其有的孩子节点的个数
    int i;
    for (i = 0; i < Vexnum; i++) {
        parent[i] = i;
        child[i] = 0;
    }
    //对边集数组进行排序，按照权重从小到达排序
    qsort(edge_tag, edge, sizeof(Edge), cmp);
    int count_vex; //记录输出的边的条数

    count_vex = i = 0;
    while (i != edge) {
        //如果两颗树可以组合在一起，说明该边是生成树的一条边
        if (union_tree(edge_tag[i], parent, child)) {
            cout << ("v" + std::to_string(edge_tag[i].start))
                << "-----"
                << ("v" + std::to_string(edge_tag[i].end))
                <<"="
                << edge_tag[i].weight
                << endl;
            edge_tag[i].visit = true;
            ++count_vex; //生成树的边加1
        }
        //这里表示所有的边都已经加入成功
        if (count_vex == Vexnum - 1) {
            break;
        }
        ++i;
    }

    if (count_vex != Vexnum - 1) {
        cout << "非连通图,无法构成最小生成树。" << endl;
    }
    delete [] edge_tag;
    delete [] parent;
    delete [] child;
}

Kruskal

四、关于作业

作业的一些关于最小生成树算法的小题，要对两种算法的实现逻辑和原理都要理解到位，以及得到最小生成树的过程要熟练。

因为第六章的内容很多，还有一些要点课程上没有安排，所以还要课下自己找时间去了解消化一下。

关于作业代码题：列出连通集

/*给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。 */
#include <cstdio>
#include <queue>
#include <iostream>
using namespace std;
#define MAX 10
int a[MAX][MAX], dfs_visited[MAX], bfs_visited[MAX], N, E;  //dfs_visited数组表示dfs
queue<int> q;
void dfs(int c)
{
    dfs_visited[c] = 1;         //1表示访问过了
    cin >> c;
    for(int i = 0; i < N; i++)
        if(a[c][i] && !dfs_visited[i])  //利用二维数组的一行就是该节点的邻接点，如果那个邻接点还没没访问过则递归访问
            dfs(i);
}
void bfs(int c)
{
    bfs_visited[c] = 1;         //1表示访问过了
    q.push(c);
    cout << c;
    while(!q.empty())
    {  
  //如果队列不空则每次从队列中取出一个节点找出该节点的第一层bfs节点，并加入队列中
        int temp = q.front();
        q.pop();
        for(int i = 0; i < N; i++)
       {//找出第一层bfs的节点,依次输出并加入队列，跟树的层次遍历很像
            if(a[temp][i] && !bfs_visited[i]){
                cout << i;      
                bfs_visited[i] = 1;
                q.push(i);
            }       
        }
    }
}
int main()
{
    int temp1, temp2;
    cin >> N >> E;
    for(int i = 0; i < E; i++)
   {
        cin >> temp1 << temp2;
        a[temp1][temp2] = 1;        //因为是无向图所有邻接矩阵是关于主对角线对称的
        a[temp2][temp1] = 1;
    }
    for(int i = 0; i < N; i++)
   {
        if(!dfs_visited[i])
         {
            cout << "{" ;
            dfs(i);
             cout << "{" ;
        }
    }

    for(int i = 0; i < N; i++)
   {
        if(!bfs_visited[i])
        {
            cout << "{" ;
            bfs(i);
            cout << "{" ;
        }
    }
    return 0;
}

列出连通集

实践题代码稍有一点坑，还在修改，大概的思路就是对于每个点，用struct去定义存储结构，存x、y坐标、能到的点的编号、能到达点的数目、能否为起点、能否为终点。输入x、y坐标点后，扫描所有的点，选择能起跳的点，判断能否作为起点，以及能否作为终点。最特殊情况下，判断可跳距离大于最大42.5时，可直接跳出矩形。

#include <iostream>
#include <cstdio>
#include <cmath>
#define max 102
using namespace std;

struct danger
{
    int x,y;
};//定义一个结构体存放每个顶点的坐标 

danger p[max]; //定义一个结构体数组来存放所有的点 
bool visit[max]={false};  
//定义一个全局变量来记录每个点是否已经去过 
int n,l;

double dis(danger a,danger b)
{//计算两个点之间的距离，注意添加头文件 
    return sqrt(pow((a.x-b.x),2)+pow((a.y-b.y),2));
}
void DFS(int v)
{//就是dfs遍历 
    visit[v]=true;//已经走过这个点就标记一下 
    if(abs(50-p[v].x)<=l || abs(50-p[v].y)<=l)
    {
    //如果这个点到边缘的距离是可以跳过去的（往上下左右方向，不是点到点的距离哦） 
        cout<<"Yes";
        exit(0) ;//程序结束输出yes 
    }
    else
    {//否则就找下一个能跳的点 
        for(int i=0;i<n;i++)
        {//所有的点都遍历一遍 
            if(!visit[i] && (dis(p[i],p[v])<=l))
                  DFS(i);
        //如果有顶点没去过而且还可以跳过去的话就从那个点开始重新找下一个点       
        }
    }
}
int main()
{
    int num=0;
    int first[max];
    danger ori;
    cin>>n>>l;
    for(int i=0;i<n;i++)
    {//接收输入数据 
        cin>>p[i].x>>p[i].y;
    }
    ori.x=ori.y=0;
    for(int i=0;i<n;i++)
    {//首先先算一下第一次能跳的点有多少个 
        if(dis(p[i],ori)<=l+7.5)
        {
            first[num++]=i;
        }
    }
    if(num==0)
    {//如果第一次都没有可以跳的点就直接是no了 
        cout<<"No";
        return 0;
    }
    for(int i=0;i<num;i++)
    {//否则就从这么点开始试试每一条路径 
        DFS(first[i]);
    }
    cout<<"No";
}

参考代码

参考链接：http://www.cnblogs.com/jingjing1234/p/10885498.html

五、小结目标

其实现在老师安排的小测可以提高对课程要点的掌握，找到自己知识点的错漏，及时理解，以及加深理解一些知识点的区别和应用。第六章的内容真的很多，要总结起来的话还有好多需要列出来，所以还要另找时间好好的追究一下课本的内容。快到期末了，也要开始对之前内容的复习以及将前面的内容和新的知识充分融合运用起来。总感觉好像开学没多久，现在就一个学期的网课也快结束了，是一个安静的毕业季啊。

 自动判断中文中文(简体)中文(香港)中文(繁体)英语日语朝鲜语德语法语俄语泰语南非语阿拉伯语阿塞拜疆语比利时语保加利亚语加泰隆语捷克语威尔士语丹麦语第维埃语希腊语世界语西班牙语爱沙尼亚语巴士克语法斯语芬兰语法罗语加里西亚语古吉拉特语希伯来语印地语克罗地亚语匈牙利语亚美尼亚语印度尼西亚语冰岛语意大利语格鲁吉亚语哈萨克语卡纳拉语孔卡尼语吉尔吉斯语立陶宛语拉脱维亚语毛利语马其顿语蒙古语马拉地语马来语马耳他语挪威语(伯克梅尔)荷兰语北梭托语旁遮普语波兰语葡萄牙语克丘亚语罗马尼亚语梵文北萨摩斯语斯洛伐克语斯洛文尼亚语阿尔巴尼亚语瑞典语斯瓦希里语叙利亚语泰米尔语泰卢固语塔加路语茨瓦纳语土耳其语宗加语鞑靼语乌克兰语乌都语乌兹别克语越南语班图语祖鲁语自动选择中文中文(简体)中文(香港)中文(繁体)英语日语朝鲜语德语法语俄语泰语南非语阿拉伯语阿塞拜疆语比利时语保加利亚语加泰隆语捷克语威尔士语丹麦语第维埃语希腊语世界语西班牙语爱沙尼亚语巴士克语法斯语芬兰语法罗语加里西亚语古吉拉特语希伯来语印地语克罗地亚语匈牙利语亚美尼亚语印度尼西亚语冰岛语意大利语格鲁吉亚语哈萨克语卡纳拉语孔卡尼语吉尔吉斯语立陶宛语拉脱维亚语毛利语马其顿语蒙古语马拉地语马来语马耳他语挪威语(伯克梅尔)荷兰语北梭托语旁遮普语波兰语葡萄牙语克丘亚语罗马尼亚语梵文北萨摩斯语斯洛伐克语斯洛文尼亚语阿尔巴尼亚语瑞典语斯瓦希里语叙利亚语泰米尔语泰卢固语塔加路语茨瓦纳语土耳其语宗加语鞑靼语乌克兰语乌都语乌兹别克语越南语班图语祖鲁语有道翻译百度翻译谷歌翻译谷歌翻译（国内）翻译 朗读 复制 正在查询，请稍候…… 重试 朗读 复制 复制 朗读 复制 via 译