图的相关概念和定义

最新推荐文章于 2023-09-02 09:49:35 发布

爱吃老谈酸菜的DV

最新推荐文章于 2023-09-02 09:49:35 发布

阅读量683

点赞数

分类专栏：数据结构课程笔记

本文链接：https://blog.csdn.net/weixin_43460224/article/details/103302202

版权

数据结构课程笔记专栏收录该内容

18 篇文章 1 订阅

订阅专栏

一、图的逻辑结构

（一）图的定义
图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G=(V，E)
ps：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。

（二）基本概念

1.无向边：顶点vi和vj之间的边没有方向，表示为(vi,vj)。
2.无向图：顶点vi和vj之间的边没有方向，表示为(vi,vj)。
3.有向边：从顶点vi到vj的边有方向，表示为<vi,vj>。
4.有向图：图的任意两个顶点之间的边都是有向边。
5.简单图：若不存在顶点到其自身的边，且同一条边不重复出现。
6.邻接、依附：无向图中，对于任意两个顶点vi和顶点vj，若存在边(vi，vj)，则称顶点vi和顶点vj互为邻接点，同时称边(vi，vj)依附于顶点vi和顶点vj。
7.无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
8.有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。

（三）基本术语

1.稀疏图：称边数很少的图为稀疏图；
2.稠密图：称边数很多的图为稠密图。
3.顶点的度：在无向图中，顶点v的度是指依附于该顶点的边数，通常记为TD (v)。
4.顶点的入度：在有向图中，顶点v的入度是指以该顶点为弧头的弧的数目，记为ID (v)；
5.顶点的出度：在有向图中，顶点v的出度是指以该顶点为弧尾的弧的数目，记为OD (v)。
6.权：是指对边赋予的有意义的数值量。
7.网：边上带权的图，也称网图。
8.路径：在无向图G=(V, E)中，从顶点vp到顶点vq之间的路径是一个顶点序列(vp=vi0,vi1,vi2, …,vim=vq)，其中，(vij-1,vij)∈E（1≤j≤m）。若G是有向图，则路径也是有方向的，顶点序列满足<vij-1,vij>∈E。
9.路径长度：对于非带权图是路径上边的个数；对于带权图是路径上各边的权之和
10.回路（环）：第一个顶点和最后一个顶点相同的路径。
11.简单路径：序列中顶点不重复出现的路径。
12.简单回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。
13.子图：若图G=（V，E），G’=（V’，E’），如果V’V 且E’  E ，则称图G’是G的子图。
14.连通图：在无向图中，如果从一个顶点vi到另一个顶点vj(i≠j)有路径，则称顶点vi和vj是连通的。如果图中任意两个顶点都是连通的，则称该图是连通图。
15.连通分量：非连通图的极大连通子图称为连通分量。
16.强连通图：在有向图中，对图中任意一对顶点vi和vj (i≠j)，若从顶点vi到顶点vj和从顶点vj到顶点vi均有路径，则称该有向图是强连通图。
17.强连通分量：非强连通图的极大强连通子图。
18.生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。
18.生成森林：在非连通图中，由每个连通分量都可以得到一棵生成树，这些连通分量的生成树就组成了一个非连通图的生成森林。

（四）图的遍历操作

深度优先遍历（DFS）：
基本思想：
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
广度优先遍历（BFS）
基本思想：
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。

（五）图的存储结构及实现
1.邻接矩阵（数组表示法）
假设图G＝(V，E)有n个顶点，则邻接矩阵是一个n×n的方阵
在这里插入图片描述
2.网图：

3.定义类：

const int MaxSize=10; 
template <class T>
class Mgraph{
   public:
      MGraph(T a[ ], int n, int e );   
       ~MGraph( )
       void DFSTraverse(int v); 
       void BFSTraverse(int v);
        ……
   private:
       T vertex[MaxSize]; 
       int arc[MaxSize][MaxSize]; 
       int vertexNum, arcNum; 
};

邻接矩阵中图的基本操作——构造函数

template <class T>
MGraph::MGraph(T a[ ], int n, int e) {
    vertexNum=n; arcNum=e;
    for (i=0; i<vertexNum; i++) 
        vertex[i]=a[i];
    for (i=0; i<vertexNum; i++)    //初始化邻接矩阵
	   for (j=0; j<vertexNum; j++)
           arc[i][j]=0;             
    for (k=0; k<arcNum; k++) {
        cin>>i>>j;     //边依附的两个顶点的序号
        arc[i][j]=1;  arc[j][i]=1;  //置有边标志    
    }
}

邻接矩阵中图的基本操作——深度优先遍历

int visited[MaxSize];
template <class T>
void MGraph::DFSTraverse(int v)  
{
     cout<<vertex[v]; visited [v]=1;
     for (j=0; j<vertexNum; j++)
         if (arc[v][j]==1 && visited[j]==0)
           DFSTraverse( j );
}

邻接矩阵中图的基本操作——广度优先遍历

int visited[MaxSize];
template <class T>
void MGraph::BFSTraverse(int v){     
    front=rear=-1;   //假设采用顺序队列且不会发生溢出
   int Q[MaxSize]; cout<<vertex[v]; visited[v]=1;  Q[++rear]=v; 
    while (front!=rear)    {
         v=Q[++front];   
         for (j=0; j<vertexNum; j++)
            if (arc[v][j]==1 && visited[j]==0 ) {
                  cout<<vertex[j]; visited[j]=1; Q[++rear]=j;
            }
      }
}

增加一个顶点：

template <class T>
void MGraph<T>::InsertVex(int num,T name) { 
 if ( num<0|| num>vertexNum) throw "位置";     
 int row, col, numv; 
 numv = vertexNum-1;
vertexNum++;    
for(int i=numv;i>=num;i--)	vertex[i++]=vertex[i];  
vertex[num]=name;    
 for(row=numv;row>=0;row--)  {所有行上num列之后的列后移，增加一列，
    for(col=numv;col>=num;col--)  arc[row][col+1]=arc[row][col];
     arc[row][num]=0;
  }
  for(row=numv;row>=num;row--) 
        for(col=0;col<=numv+1;col++)  arc[row+1][col]=arc[row][col];	
  for(col=0;col<vertexNum;col++)  arc[num][col]=0; 
 }

删除一个顶点

template <class T>   
void MGraph<T>::DeleteVex(int pos){
     if ( pos<0||  pos>MaxSize) throw "位置";   
     int row， col;    
     int numv=vertexNum;    
     for(int i=pos;i<numv;i++)   vertex[i]=vertex[i+1];    
     vertexNum--;                            
     for(row=0;row<numv;row++)   { //删除一列
         for(col=pos;col<numv;col++)	  arc[row][col]=arc[row][col+1];  
    }
    for(row=pos;row<numv;row++) 
	  for(col=0;col<numv;col++)
		  arc[row][col]=arc[row+1][col];      
  } 
}

插入一条边

template <class T>
void MGraph<T>::InsertArc(int i, int j)
{
  if ( i>MaxSize||  j>MaxSize) throw "位置";  
  arc[i][j]=1;
  arc[j][i]=1;
}

删除一条边

template <class T>
void MGraph<T>::DeleteArc(int i, int j)
{
         if ( i>MaxSize||  j>MaxSize) throw "位置";
         arc[i][j]=arc[j][i]=0;   
}

4.邻接表

邻接表有两种结点结构：顶点表结点和边表结点。
在这里插入图片描述
vertex：数据域，存放顶点信息。
firstedge：指针域，指向边表中第一个结点。
adjvex：邻接点域，边的终点在顶点表中的下标。
next：指针域，指向边表中的下一个结点。

定义邻接表的结点

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

插入边

template <class T>
void ALGraph<T>::InsertArc(int i, int j)
{
    if ( i>MaxSize || j>MaxSize)
        throw "位置";
    ArcNode *s=new ArcNode;
    s->adjvex=j;
    s->next=adjlist[i].firstedge;
    adjlist[i].firstedge=s;
}

删除边

template <class T>
void ALGraph<T>::DeleteArc(int i, int j)
{
    if ( i>MaxSize||  j>MaxSize)
        throw "位置";
    ArcNode *s;
    ArcNode *pre;
    s = adjlist[i].firstedge;
    if (!s)
        return;
    if(s->adjvex==j)
    {
        adjlist[i].firstedge=s->next;
        return;
    }
    pre = adjlist[i].firstedge;
    while(s!=NULL && s->adjvex!=j)
    {
        pre = s;
        s = s->next;
    }
    if(s!=NULL)
    {
        pre->next = s->next;
        delete s;
    }
}

插入顶点

template <class T>
void ALGraph<T>::InsertVex( T value)
{
    if ( i>vertexNum || i<0 || i>MaxSize )
        throw "顶点位置异常";
    vertexNum++; 
    VertexNode<T> tempvertex;
    tempvertex.vertex = value;
    tempvertex.firstedge = NULL;
    adjlist[VertexNum-1] = tempvertex;
}

删除一个顶点

template <class T>
void ALGraph<T>::DeleteVex(int i)
{
    if ( i<0 || i>MaxSize)
        throw "位置";
    int k;
    for ( k=0; k<vertexNum; k++)    //删掉入度边
        if(k!=i)
            DeleteArc(k, i);
    ArcNode *s;       //删除i的边表
    if( adjlist[i].firstedge != NULL)
    {
        ArcNode *s;
        s=adjlist[i].firstedge->next;
        while(s!=NULL)
        {
            ArcNode *p;
            p = s;
            adjlist[i].firstedge->next = s->next;
            s=s->next;
            delete p; //删除p结点
        }

        s=adjlist[i].firstedge;
        delete s;
        adjlist[i].firstedge=NULL;
    }
    for (k=i; k<vertexNum; k++) //删除顶点表中的顶点
        adjlist[k]=adjlist[k+1];
    vertexNum--;      //顶点数减1
    for (k=0; k<vertexNum; k++)  //修改边表中节点的编号
        if( adjlist[k].firstedge != NULL )
        {
            s=adjlist[k].firstedge;
            while(s!=NULL)
            {
                if(s->adjvex > i)  //搜索编号大于i结点
                    s->adjvex--;
                s = s->next;
            }
        }
}

5.边集数组的实现

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

爱吃老谈酸菜的DV

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
图的相关概念和定义

一、图的逻辑结构（一）图的定义图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G=(V，E)ps：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。（二）基本概念1.无向边：顶点vi和vj之间的边没有方向，表示为(vi,vj)。2.无向图：顶点vi和vj之间的边没有方向，表示为(vi,vj)。3.有向边：从顶点vi到vj的边有方向，表示为<vi,vj...
复制链接

扫一扫