图的基本概念与邻接矩阵的实现
离散图论知识点总结
离散图论知识点总结一、基本概念图（Graph）是离散数学中的一个重要概念，它由顶点集合V和边集合E组成。
一般用G （V，E）来表示，其中V={v1,v2,…,vn}是有限非空集合，E是V中元素的无序对的集合。
图分为有向图和无向图。
无向图中的边是无序的，有向图中的边是有序的。
图中存在一些特殊的图，比如完全图、树、路径、回路等。
二、图的表示方法1. 邻接矩阵邻接矩阵是一种常见的图的表示方法，它使用一个二维数组来表示图的关系。
对于一个n 个顶点的图，邻接矩阵是一个n*n的矩阵A，其中A[i][j]表示顶点i到顶点j之间是否存在边。
对于无向图，A[i][j]=1表示顶点i与顶点j之间存在边，A[i][j]=0表示不存在。
对于有向图，A[i][j]=1表示i指向j的边存在，A[i][j]=0表示不存在。
2. 邻接表邻接表是另一种常见的图的表示方法。
它将图的信息储存在一个数组中，数组的每个元素与图的一个顶点相对应。
对于每个顶点vi，数组中储存与该顶点邻接的顶点的信息。
邻接表可以用链表或者数组来表示，链表表示的邻接表比较灵活，但是在查找某个边的相邻顶点时需要遍历整个链表。
三、图的性质1. 度图中每个顶点的度是与其相邻的边的数目。
对于无向图，顶点的度等于与其相邻的边的数目；对于有向图，则分为入度和出度。
2. 连通性对于无向图G，若图中任意两个顶点都有路径相连，则称图G是连通的。
对于有向图G，若从任意一个顶点vi到任意一个顶点vj都存在路径，则称G是强连通的。
3. 路径和回路路径是指图中一系列的边，连接图中的两个顶点；回路是指起点与终点相同的路径。
路径的长度是指路径中边的数目。
4. 树和森林一个无向图，如果是连通图且不存在回路，则称为树。
一个无向图，若它不是连通图，则称为森林。
四、图的常见算法1. 深度优先搜索（DFS）深度优先搜索是一种用于图的遍历的算法，它从图的某个顶点vi出发，访问它的所有邻接顶点，再对其中未访问的顶点继续深度优先搜索。
图的基本概念
图的同构
• 定义:给定两个图G1=(V1,E1)和G2=(V2,E2).如果 在V1和V2之间存在双射f 使得 (u,v)E1 iff (f(uБайду номын сангаас, f(v))E2 则称G1和G2同构(isomorphic),记作 G1 G2 .
• 若 G1 G2,则有
(1) |V(G1)| = |V(G2)|, |E(G1)| = |E(G2)|; (2) G1和G2结点度的非增序列相同; (3) G1的任一导出子图在G2中都有与之同构的导出子
Lu Chaojun, SJTU
24
图的表示法:邻接表
• 将正向表的m维向量B拆成n个列表,第i个 列表存储vi的所有后继.
• 列表通常采用链表结构. • 链表中每个单元除了可以存储后继结点,
还可以存储权值,形如:
vi
vi的(直接)后继# wij
Lu Chaojun, SJTU
25
End
Lu Chaojun, SJTU
(2) 图G中度为奇数的结点必有偶数个. (3) 有向图中:正度之和=负度之和=边数. (4) Kn的边数为n(n1)2. (5) 非空简单图中一定存在度相同的结点.
Lu Chaojun, SJTU
9
赋权图
• 定义:如果给图G=(V,E)的每条边ek 都赋以 一个实数wk作为该边的权(weight),则称G 是赋权图.
图;反之亦然.
Lu Chaojun, SJTU
16
例:同构
• 下图显示了图G与它的补图同构.
Lu Chaojun, SJTU
17
例题
证明:任意6个人中必有三人相互认识或者有三人 互不相识.
证:作K6并给边涂色:红=认识,蓝=不认识.只要证图 中必有同色三角形. v1有5条边,由抽屉原则必有三边同色(设为红), 这三边的另一顶点设为v2, v3, v4. △v2v3v4有一边为红色,则与v1构成红色△; △v2v3v4的三边无红色,则构成蓝色△.
图的基本操作与应用
图的基本操作与应用图是一种重要的数据结构，广泛应用于计算机科学和相关领域。
本文将介绍图的基本操作和常见的应用场景，通过详细讲解来帮助读者更好地理解和应用图。
一、图的定义和表示图是由节点（顶点）和边组成的集合。
节点表示实体，边表示节点之间的关系。
图可以用以下方式进行表示：邻接矩阵和邻接表。
1. 邻接矩阵：用二维数组表示图的连接关系，其中数组元素a[i][j]表示节点i到节点j是否存在一条边。
2. 邻接表：使用链表或数组的方式表示节点的连接关系。
每个节点对应一个链表，链表中存储与该节点相连接的其他节点。
二、图的基本操作1. 添加节点：图中可以通过添加节点来增加实体。
添加节点时，需要更新相应的连接关系，即在邻接矩阵或邻接表中添加对应的行或节点。
2. 添加边：向图中添加边可以表示节点之间的关系。
在邻接矩阵中，将对应的元素设置为1。
在邻接表中，将对应的节点添加到该节点的链表中。
3. 删除节点：从图中删除节点时，需要将与该节点相关的边一并删除。
删除节点后，对应的行或链表也需要进行相应的调整。
4. 删除边：删除边可以断开节点之间的关系。
在邻接矩阵中，将对应的元素设置为0。
在邻接表中，删除对应的节点。
三、图的应用场景1. 社交网络分析：图可以用于分析社交网络中的关系，如朋友关系、粉丝关系等。
可以通过图的遍历算法，寻找潜在的朋友或影响力人物。
2. 路径规划：图可以表示地理空间中的路径，如导航系统中的道路网络。
可以使用图的最短路径算法，如Dijkstra算法或A*算法，来计算最优路径。
3. 组织架构图：图可以用于表示组织或公司的架构，帮助人们更好地理解不同部门之间的关系和沟通路径。
4. 网络流量分析：图可以用于分析网络中的流量，如网络路由、数据传输等。
可以通过图的最大流算法，如Ford-Fulkerson算法，来优化网络流量分配和传输效率。
5. 数据库关系图：图可以用于表示数据库中的关系表，帮助人们理解和查询表之间的关系，如主外键关系等。
图论导引参考答案
图论导引参考答案图论导引参考答案图论是数学中的一个分支，研究的是图的性质和图之间的关系。
图由节点和边组成，节点表示对象，边表示对象之间的连接关系。
图论在计算机科学、网络分析、社交网络等领域有着广泛的应用。
本文将介绍图论的基本概念和常见算法，并提供一些参考答案来帮助读者更好地理解和应用图论。
一、图的基本概念1.1 有向图和无向图图可以分为有向图和无向图两种类型。
有向图中，边有方向，表示节点之间的单向关系；而无向图中，边没有方向，表示节点之间的双向关系。
1.2 路径和环路径是指图中一系列节点和边的连续序列，路径的长度为路径中边的数量。
如果路径的起点和终点相同，则称之为环。
1.3 连通图和连通分量在无向图中，如果任意两个节点之间都存在路径，则称该图为连通图。
连通图中的极大连通子图称为连通分量。
1.4 强连通图和强连通分量在有向图中，如果任意两个节点之间都存在路径，则称该图为强连通图。
强连通图中的极大强连通子图称为强连通分量。
二、图的存储方式2.1 邻接矩阵邻接矩阵是一种常见的图的存储方式，使用一个二维矩阵来表示图中节点之间的连接关系。
矩阵的行和列分别表示节点，矩阵中的元素表示节点之间是否存在边。
2.2 邻接表邻接表是另一种常见的图的存储方式，使用一个数组和链表的结构来表示图中节点之间的连接关系。
数组中的每个元素表示一个节点，链表中的每个节点表示与该节点相连的边。
三、常见图算法3.1 深度优先搜索（DFS）深度优先搜索是一种用于遍历图的算法。
从图中的一个节点开始，沿着一条路径一直深入直到无法继续为止，然后回溯到上一个节点，继续深入其他路径。
DFS可以用于判断图的连通性、寻找路径等问题。
3.2 广度优先搜索（BFS）广度优先搜索也是一种用于遍历图的算法。
从图中的一个节点开始，先访问其所有相邻节点，然后再依次访问这些节点的相邻节点，以此类推。
BFS可以用于计算最短路径、寻找连通分量等问题。
3.3 最小生成树算法最小生成树算法用于求解一个连通图的最小生成树，即包含图中所有节点且边的权重之和最小的子图。
ACM基础——图
Status CreateMG(MGraph &G){ //无向图的构造 int i,j,k,v1,v2; scanf("%d%d",&G.vexnum,&G.arcnum); for(i=0;i<G.vexnum;i++) scanf(“%d”,&G.vexs[i]); //输入顶点数据 for(i=0;i<G.vexnum;i++) for(j=0;j<G.vexnum;j++) G.arcs[i][j].adj = 0; //初始化结束 for(k=0;k<G.arcnum;k++){ scanf("%d%d",&v1,&v2); i=LocateVex(G,v1); j=LocateVex(G,v2); G.arcs[i][j].adj=1; G.arcs[j][i].adj=G.arcs[i][j].adj; //创建有向图屏蔽此句 } return OK; }
0 0 0
1
1 0 0
Байду номын сангаас
3
2 1 2
V2
V4
V3 V4
图的邻接矩阵表示
# define INFINITY INT_MAX //表示不可达 # define MAX_VERTEX_NUM 20 //最大顶点个数
typedef int VRType;
//顶点关系类型
typedef int VertexType; //顶点数据类型
图
• 图的基本概念 • 图的存储 • 图的遍历
图(Graph)是由有穷非空的顶点集合和一个描述 顶点之间关系的边（或者弧）的集合组成。
图基本算法图的表示方法邻接矩阵邻接表
图基本算法图的表⽰⽅法邻接矩阵邻接表 要表⽰⼀个图G=(V,E)，有两种标准的表⽰⽅法，即邻接表和邻接矩阵。
这两种表⽰法既可⽤于有向图，也可⽤于⽆向图。
通常采⽤邻接表表⽰法，因为⽤这种⽅法表⽰稀疏图（图中边数远⼩于点个数）⽐较紧凑。
但当遇到稠密图（|E|接近于|V|^2）或必须很快判别两个给定顶点⼿否存在连接边时，通常采⽤邻接矩阵表⽰法，例如求最短路径算法中，就采⽤邻接矩阵表⽰。
图G=<V，E>的邻接表表⽰是由⼀个包含|V|个列表的数组Adj所组成，其中每个列表对应于V中的⼀个顶点。
对于每⼀个u∈V，邻接表Adj[u]包含所有满⾜条件（u，v）∈E的顶点v。
亦即，Adj[u]包含图G中所有和顶点u相邻的顶点。
每个邻接表中的顶点⼀般以任意顺序存储。
如果G是⼀个有向图，则所有邻接表的长度之和为|E|，这是因为⼀条形如（u，v）的边是通过让v出现在Adj[u]中来表⽰的。
如果G是⼀个⽆向图，则所有邻接表的长度之和为2|E|，因为如果（u，v）是⼀条⽆向边，那么u会出现在v的邻接表中，反之亦然。
邻接表需要的存储空间为O（V+E）。
邻接表稍作变动，即可⽤来表⽰加权图，即每条边都有着相应权值的图，权值通常由加权函数w：E→R给出。
例如，设G=<V，E>是⼀个加权函数为w的加权图。
对每⼀条边（u，v)∈E，权值w（u，v）和顶点v⼀起存储在u的邻接表中。
邻接表C++实现:1 #include <iostream>2 #include <cstdio>3using namespace std;45#define maxn 100 //最⼤顶点个数6int n, m; //顶点数，边数78struct arcnode //边结点9 {10int vertex; //与表头结点相邻的顶点编号11int weight = 0; //连接两顶点的边的权值12 arcnode * next; //指向下⼀相邻接点13 arcnode() {}14 arcnode(int v,int w):vertex(v),weight(w),next(NULL) {}15 arcnode(int v):vertex(v),next(NULL) {}16 };1718struct vernode //顶点结点，为每⼀条邻接表的表头结点19 {20int vex; //当前定点编号21 arcnode * firarc; //与该顶点相连的第⼀个顶点组成的边22 }Ver[maxn];2324void Init() //建⽴图的邻接表需要先初始化，建⽴顶点结点25 {26for(int i = 1; i <= n; i++)27 {28 Ver[i].vex = i;29 Ver[i].firarc = NULL;30 }31 }3233void Insert(int a, int b, int w) //尾插法，插⼊以a为起点，b为终点，权为w的边，效率不如头插，但是可以去重边34 {35 arcnode * q = new arcnode(b, w);36if(Ver[a].firarc == NULL)37 Ver[a].firarc = q;38else39 {40 arcnode * p = Ver[a].firarc;41if(p->vertex == b) //如果不要去重边，去掉这⼀段42 {43if(p->weight < w)44 p->weight = w;45return ;46 }47while(p->next != NULL)48 {49if(p->next->vertex == b) //如果不要去重边，去掉这⼀段50 {51if(p->next->weight < w);52 p->next->weight = w;53return ;54 }55 p = p->next;56 }57 p->next = q;58 }59 }60void Insert2(int a, int b, int w) //头插法，效率更⾼，但不能去重边61 {62 arcnode * q = new arcnode(b, w);63if(Ver[a].firarc == NULL)64 Ver[a].firarc = q;65else66 {67 arcnode * p = Ver[a].firarc;68 q->next = p;69 Ver[a].firarc = q;70 }71 }7273void Insert(int a, int b) //尾插法，插⼊以a为起点，b为终点，⽆权的边，效率不如头插，但是可以去重边74 {75 arcnode * q = new arcnode(b);76if(Ver[a].firarc == NULL)77 Ver[a].firarc = q;78else79 {80 arcnode * p = Ver[a].firarc;81if(p->vertex == b) return; //去重边，如果不要去重边，去掉这⼀句82while(p->next != NULL)83 {84if(p->next->vertex == b) //去重边，如果不要去重边，去掉这⼀句85return;86 p = p->next;87 }88 p->next = q;89 }90 }91void Insert2(int a, int b) //头插法，效率跟⾼，但不能去重边92 {93 arcnode * q = new arcnode(b);94if(Ver[a].firarc == NULL)95 Ver[a].firarc = q;96else97 {98 arcnode * p = Ver[a].firarc;99 q->next = p;100 Ver[a].firarc = q;101 }102 }103void Delete(int a, int b) //删除以a为起点，b为终点的边104 {105 arcnode * p = Ver[a].firarc;106if(p->vertex == b)107 {108 Ver[a].firarc = p->next;109 delete p;110return ;111 }112while(p->next != NULL)113if(p->next->vertex == b)114 {115 p->next = p->next->next;116 delete p->next;117return ;118 }119 }120121void Show() //打印图的邻接表（有权值）122 {123for(int i = 1; i <= n; i++)124 {125 cout << Ver[i].vex;126 arcnode * p = Ver[i].firarc;127while(p != NULL)128 {129 cout << "->(" << p->vertex << "," << p->weight << ")";130 p = p->next;131 }132 cout << "->NULL" << endl;133 }134 }135136void Show2() //打印图的邻接表(⽆权值）137 {138for(int i = 1; i <= n; i++)140 cout << Ver[i].vex;141 arcnode * p = Ver[i].firarc;142while(p != NULL)143 {144 cout << "->" << p->vertex;145 p = p->next;146 }147 cout << "->NULL" << endl;148 }149 }150int main()151 {152int a, b, w;153 cout << "Enter n and m：";154 cin >> n >> m;155 Init();156while(m--)157 {158 cin >> a >> b >> w; //输⼊起点、终点159 Insert(a, b, w); //插⼊操作160 Insert(b, a, w); //如果是⽆向图还需要反向插⼊161 }162 Show();163return0;164 }View Code 邻接表表⽰法也有潜在的不⾜之处，即如果要确定图中边（u,v）是否存在，只能在顶点u邻接表Adj[u]中搜索v，除此之外没有其他更快的办法。
邻接矩阵的乘法
邻接矩阵的乘法邻接矩阵是图论中最基本的数据结构之一，它用于表示有向图和无向图中的顶点和边。
邻接矩阵乘法是计算两个邻接矩阵相乘的算法，它在图论和计算机科学领域中都有广泛应用。
本文将详细介绍邻接矩阵乘法的概念、实现方法和应用场景。
一、概念1. 邻接矩阵邻接矩阵是一个二维数组，其中每个元素表示两个顶点之间是否存在一条边。
对于无向图而言，邻接矩阵是一个对称矩阵；对于有向图而言，邻接矩阵则不一定是对称的。
2. 邻接矩阵乘法邻接矩阵乘法是指将两个有向图或无向图的邻接矩阵相乘得到一个新的邻接矩阵。
在计算机科学中，通常使用这种方法来计算两个图之间的路径或者连接关系。
二、实现方法1. 常规算法常规的邻接矩阵乘法算法需要进行三重循环操作。
具体来说，就是先将第一个邻接矩阵的每一行和第二个邻接矩阵的每一列相乘，然后将结果相加得到新的邻接矩阵。
这种算法的时间复杂度为O(n^3)。
2. Strassen算法Strassen算法是一种优化的邻接矩阵乘法算法，它将三重循环操作转换成了七个子问题。
通过递归调用自身来解决这些子问题，可以将时间复杂度降低到O(n^2.81)。
3. Coppersmith-Winograd算法Coppersmith-Winograd算法是目前已知的最快的邻接矩阵乘法算法，它将时间复杂度降低到了O(n^2.376)。
该算法使用了分治和线性代数的技巧，并且需要大量的预处理和内存空间。
三、应用场景1. 图论中的最短路径问题在图论中，最短路径问题是指找到两个顶点之间距离最短的路径。
通过使用邻接矩阵乘法可以计算出两个图之间所有可能的路径，并且找出其中距离最短的一条路径。
2. 计算机网络中的路由选择在计算机网络中，路由选择是指选择从一个网络节点到另一个网络节点的最佳路径。
通过使用邻接矩阵乘法可以计算出网络中所有节点之间的距离，并且找出最佳的路由选择方案。
3. 机器学习中的矩阵运算在机器学习中，矩阵运算是非常常见的操作。
图论的基础概念和算法
图论的基础概念和算法图论是数学的一个分支，研究的对象是图。
图是由一组互不相连的节点（顶点）和连接这些节点的边（边）组成的数学结构。
图论的基础概念包括顶点、边、路径、环、度数等。
本文将介绍图论的基础概念以及常用的图算法。
一、基础概念1. 图的定义和表示图由顶点集合和边集合组成。
顶点集合用V表示，边集合用E表示。
图可以用邻接矩阵或邻接表来表示。
邻接矩阵是一个二维数组，用来表示图中顶点之间的连接关系。
邻接表是一个链表数组，用来表示每个顶点相邻顶点的列表。
2. 顶点和边顶点是图的基本组成单位，用来表示图中的一个节点。
边是连接两个顶点的线段，用来表示两个顶点之间的关系。
3. 路径和环路径是由一系列相邻顶点连接而成的顶点序列。
路径的长度是指路径上经过的边的数目。
环是起点和终点相同的路径。
4. 度数顶点的度数是指与其相邻的边的数目。
入度是指指向该顶点的边的数目，出度是指由该顶点指向其他顶点的边的数目。
图中顶点的度数可以用来判断顶点的重要性。
二、常用算法1. 广度优先搜索（BFS）广度优先搜索是一种用来遍历和搜索图的算法。
从一个起始顶点开始，逐层扩展，先访问距离起始顶点最近的顶点，然后访问它们的相邻顶点，并逐渐向外扩展。
广度优先搜索可以用来计算两个顶点之间的最短路径。
2. 深度优先搜索（DFS）深度优先搜索是另一种常用的图遍历算法。
从一个起始顶点开始，沿着一条路径尽可能深入地访问图，直到不能再继续深入为止，然后回溯到上一个顶点，继续探索其他路径。
深度优先搜索可以用来计算连通分量、拓扑排序和寻找环等。
3. 最小生成树最小生成树是指图中通过连接所有顶点的子图，并且该子图的边权重之和最小。
常用的最小生成树算法包括Prim算法和Kruskal算法。
Prim算法从一个顶点开始，逐步扩展最小生成树的边，直到包含所有顶点为止。
Kruskal算法则是从边的权重最小的边开始，逐步增加边到最小生成树中，直到包含所有顶点为止。
4. 最短路径算法最短路径算法用来计算两个顶点之间的最短路径。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
有向图、无向图
A
B
E
CD
B A
F
C D
E
邻接点、度
A
B
E
CD
B A
F
C D
E
子图
A
B
E
CD
B CD
稀疏图、稠密图
n:顶点个数 e:边数 e ≧ nlogn
int v1 = theEdge->vertex1(); int v2 = theEdge->vertex2(); if (v1 < 1 || v2 < 1 || v1 > n || v2 > n || v1 == v2)
throw std::out_of_range("invalid");
template <class T> bool adjacencyWDigraph<T>::existsEdge(int i, int j) const {// Return true iff (i,j) is an edge of the graph.
if (i < 1 || j < 1 || i > n || j > n || a[i][j] == noEdge) return false;
路径和路径长度
A
B
E
C
D
A->B->C->D A->E->C->D
简单路径
A
B
E
C
D
A->B->C->D A->E->C->D->B->C->D
连通图
B
C
A
D
F
E
a、连通图
B
C
A
D
F
E
b、非连通图
强连通图
A
B
E
CD
a、强连通图
A
B
E
CD
b、非强连通图
生成树
B A
F
C
D E
B A
F
C
D E
网
A
for (int i = 1; i <= n; i++)
// initialize adjacency matrix std::fill(a[i], a[i] + n + 1, noEdge);
A0
}
B0
C0
D0
E0
BCD E
0000 0000 0000 0000 0000
AdjacencyWDigraph
15
A9
11
B7 3
21
E
C2 D
图的存储表示
一、图的数组(邻接矩阵)存储表示 二、图的邻接表存储表示 三、有向图的十字链表存储表示 四、无向图的邻接多重表存储表示
无向图-邻接矩阵
B A
F
C D
E
ABCD E F
A010010 B100011 C000101 D0 0 1 0 0 1 E110000 F011100
else return true;
} template <class T> void adjacencyWDigraph<T>::eraseEdge(int i, int j) {// Delete the edge (i,j).
if (i >= 1 && j >= 1 && i <= n && j <= n && a[i][j] != noEdge) {
数据结构
｛a1, a2, a3, …, an} 研究数据的组织方法，以提高程序性能 。
研究在线性存储模型中，如何用顺序、链式或二者的组合 方式组织数据，以提高增、删、改、查的性能。
线性存储器模型
0 1 2 3
……
n
内存？外存？
1、编程空间 2、流式文件 3、……
实例
假设有5位同学的成绩表： 2006001 99 2006003 80 2006004 85 2006005 60 2006006 70
组织方式－顺序
存储地址 Lo
Lo+m
存储内容 元素1
元素2
……..
Lo+(i-1)*m 元素i ……..
Lo+（n-1)*m 元素n
2006001 99 2006003 80 2006004 85 2006005 60 2006006 70
组织方式－链式
存储内容
L0
元素1
P
2006001 99
元素3
1、邻接矩阵 2、邻接表 3、十字链表
V2
V1
V4
V3
类的派生层次－基于邻接矩阵
AdjacencyWDigraph
graph
AdjacencyWgraph
AdjacencyDigraph
Adjacencygraph
graph类
template<class T> class graph{
public: virtual ~graph() {} virtual int numberOfVertices() const = 0; virtual int numberOfEdges() const = 0; virtual bool existsEdge(int, int) const = 0; virtual void insertEdge(edge<T>*) = 0; virtual void eraseEdge(int, int) = 0; virtual int degree(int) const = 0; virtual int inDegree(int) const = 0; virtual int outDegree(int) const = 0; virtual bool directed() const = 0; virtual bool weighted() const = 0; virtual vertexIterator<T>* iterator(int) = 0; virtual void output(std::ostream&) const = 0;
AdjacencyWDigraph
template <class T> bool adjacencyWDigraph<T>::make2dArray(T ** &x, int numberOfRows, int numberOfColumns) {// Create a two dimensional array.
AdjacencyWDigraph
。。。。。 public:
adjacencyWDigraph(int numberOfVertices = 0, T theNoEdge = 0); ~adjacencyWDigraph(){delete2dArray(a, n + 1);}; int numberOfVertices() const{return n;} int numberOfEdges() const {return e;} bool existsEdge(int, int) const; void insertEdge(edge<T>*); void eraseEdge(int, int); int degree(int) const{throw std::invalid_argument("no degree");} int inDegree(int) const; int outDegree(int) const; bool directed() const {return true;} bool weighted() const {return true;} vertexIterator<T>* iterator(int) ; void output(std::ostream&) const ; private: bool make2dArray(T ** &x, int numberOfRows, int numberOfColumns); void checkVertex(int theVertex) const; };
if (numberOfVertices < 0)
throw std::out_of_range("number of vertices must be >= 0");
n = numberOfVertices;
e = 0;
noEdge = theNoEdge;
make2dArray(a, n + 1, n + 1);
};
AdjacencyWDigraph
template <class T> class weightedEdge : public edge<T> {
public: weightedEdge(int theV1, int theV2, T theW) {v1 = theV1; v2 = theV2; w = theW;} ~weightedEdge() {}; int vertex1() const {return v1;} int vertex2() const {return v2;} T weight() const {return w;} operator T() const {return w;} void output(std::ostream& out) const{ out << "(" << v1 << ", " << v2 << ", " << w << ")