图看起来就像下图这样：
在计算机科学中，一个图就是一些顶点的集合，这些顶点通过一系列边结对（连接）。顶点用圆圈表示，边就是这些圆圈之间的连线。顶点之间通过边连接。
注意：顶点有时也称为节点或者交点，边有时也称为链接。
一个图可以表示一个社交网络，每一个人就是一个顶点，互相认识的人之间通过边联系。
图有各种形状和大小。边可以有权重（weight），即每一条边会被分配一个正数或者负数值。考虑一个代表航线的图。各个城市就是顶点，航线就是边。那么边的权重可以是飞行时间，或者机票价格。
有了这样一张假设的航线图。从旧金山到莫斯科最便宜的路线是到纽约转机。
边可以是有方向的。在上面提到的例子中，边是没有方向的。例如，如果 Ada 认识 Charles，那么 Charles 也就认识 Ada。相反，有方向的边意味着是单方面的关系。一条从顶点 X 到 顶点 Y 的边是将 X 联向 Y，不是将 Y 联向 X。
继续前面航班的例子，从旧金山到阿拉斯加的朱诺有向边意味着从旧金山到朱诺有航班，但是从朱诺到旧金山没有（我假设那样意味着你需要走回去）。
下面的两种情况也是属于图：
左边的是树，右边的是链表。他们都可以被当成是树，只不过是一种更简单的形式。他们都有顶点（节点）和边（连接）。
第一种图包含圈（cycles），即你可以从一个顶点出发，沿着一条路劲最终会回到最初的顶点。树是不包含圈的图。
另一种常见的图类型是单向图或者 DAG：
就像树一样，这个图没有任何圈（无论你从哪一个节点出发，你都无法回到最初的节点），但是这个图有有向边（通过一个箭头表示，这里的箭头不表示继承关系）。
为什么要使用图？
也许你耸耸肩然后心里想着，有什么大不了的。好吧，事实证明图是一种有用的数据结构。
如果你有一个编程问题可以通过顶点和边表示出来，那么你就可以将你的问题用图画出来，然后使用著名的图算法（比如广度优先搜索 或者 深度优先搜索）来找到解决方案。
例如，假设你有一系列任务需要完成，但是有的任务必须等待其他任务完成后才可以开始。你可以通过非循环有向图来建立模型：
每一个顶点代表一个任务。两个任务之间的边表示目的任务必须等到源任务完成后才可以开始。比如，在任务B和任务D都完成之前，任务C不可以开始。在任务A完成之前，任务A和D都不能开始。
现在这个问题就通过图描述清楚了，你可以使用深度优先搜索算法来执行执行拓扑排序。这样就可以将所有的任务排入最优的执行顺序，保证等待任务完成的时间最小化。（这里可能的顺序之一是：A, B, D, E, C, F, G, H, I, J, K）
不管是什么时候遇到困难的编程问题，问一问自己：“如何用图来表述这个问题？”。图都是用于表示数据之间的关系。 诀窍在于如何定义“关系”。
如果你是一个音乐家你可能会喜欢这个图：
这些顶点来自C大调的和弦。这些边--表示和弦之间的关系--描述了怎样从一个和弦到另一个和弦。这是一个有向图，所以箭头的方向表示了怎样从一个和弦到下一个和弦。它同时还是一个加权图，每一条边的权重（这里用线条的宽度来表示）说明了两个和弦之间的强弱关系。如你所见，G7-和弦后是一个C和弦和一个很轻的 Am 和弦。
程序员常用的另一个图就是状态机，这里的边描述了状态之间切换的条件。下面这个状态机描述了一个猫的状态：
图真的很棒。Facebook 就从他们的社交图中赚取了巨额财富。如果计划学习任何数据结构，则应该选择图，以及大量的标准图算法。
顶点和边
理论上，图就是一堆顶点和边对象而已，但是怎么在代码中来描述呢？
有两种主要的方法：邻接列表和邻接矩阵。
邻接列表：在邻接列表实现中，每一个顶点会存储一个从它这里开始的边的列表。比如，如果顶点A 有一条边到B、C和D，那么A的列表中会有3条边
邻接列表只描述了指向外部的边。A 有一条边到B，但是B没有边到A，所以 A没有出现在B的邻接列表中。查找两个顶点之间的边或者权重会比较费时，因为遍历邻接列表直到找到为止。
邻接矩阵：在邻接矩阵实现中，由行和列都表示顶点，由两个顶点所决定的矩阵对应元素表示这里两个顶点是否相连、如果相连这个值表示的是相连边的权重。例如，如果从顶点A到顶点B有一条权重为 5.6 的边，那么矩阵中第A行第B列的位置的元素值应该是5.6：
往这个图中添加顶点的成本非常昂贵，因为新的矩阵结果必须重新按照新的行/列创建，然后将已有的数据复制到新的矩阵中。
所以使用哪一个呢？大多数时候，选择邻接列表是正确的。下面是两种实现方法更详细的比较。
假设 V 表示图中顶点的个数，E 表示边的个数。
| 操作 | 邻接列表 | 邻接矩阵 |
|---|---|---|
| 存储空间 | O(V + E) | O(V^2) |
| 添加顶点 | O(1) | O(V^2) |
| 添加边 | O(1) | O(1) |
| 检查相邻性 | O(V) | O(1) |
“检查相邻性” 是指对于给定的顶点，尝试确定它是否是另一个顶点的邻居。在邻接列表中检查相邻性的时间复杂度是O(V)，因为最坏的情况是一个顶点与每一个顶点都相连。
在 稀疏图的情况下，每一个顶点都只会和少数几个顶点相连，这种情况下相邻列表是最佳选择。如果这个图比较密集，每一个顶点都和大多数其他顶点相连，那么相邻矩阵更合适。
代码：顶点和边
先看一下边的定义：
class Edge<T>(val from: Vertex<T>,
val to: Vertex<T>,
val weight: Double? = 0.toDouble()) {
}
边包含了3个属性 “from” 和 “to” 顶点，以及权重值。注意 Edge 对象总是有方向的。如果需要添加一条无向边，你需要在相反方向添加一个 Edge 对象。weight 属性是可选的，所以加权图和未加权图都可以用它们来描述。
Vertex 的定义：
class Vertex<T>(var data: T? = null, var index: Int = 0) {
//val edgeList : List<EdgeList<T>> = emptyList()
val edges: ArrayList<Edge<T>> = ArrayList()
var visited = false
//var distance = 0
fun addEdge(edge: Edge<T>){
edges.add(edge)
}
override fun toString(): String {
return data.toString()
}
}
由于是泛型定义，所以它可以存放任何类型的数据。
图
注意：图的实现方式有很多，这里给出来的只是一种可能的实现。你可以根据不同问题来裁剪这些代码。例如你的边可能不需要
weight属性，你也可能不需要区分有向边和无向边。
这里有一个简单的图：
我们可以用邻接列表或者邻接矩阵来实现。实现这些概念的类都是继承自通用的 API AbstractGraph，所以它们可以相同的方式创建，但是背后各自使用不同的数据结构。
我们来创建一个有向加权图，来存储上面的数据：
val graph = Graph<Int>()
val v1 = graph.createVertex(1)
val v2 = graph.createVertex(2)
val v3 = graph.createVertex(3)
val v4 = graph.createVertex(4)
val v5 = graph.createVertex(5)
graph.addDirectedEdge(fromVertex = v1, toVertex = v2, weightValue = 1.0)
graph.addDirectedEdge(fromVertex = v2, toVertex = v3, weightValue = 1.0)
graph.addDirectedEdge(fromVertex = v3, toVertex = v4, weightValue = 4.5)
graph.addDirectedEdge(fromVertex = v4, toVertex = v1, weightValue = 2.8)
graph.addDirectedEdge(fromVertex = v2, toVertex = v5, weightValue = 3.2)
graph.printAdjacencyList()
前面我们已经说过，如果要添加一条无向边，需要添加两条有向边。对于无向图，我们可以使用下面的代码来替换：
graph.addUnDirectedEdge(fromVertex = v1, toVertex = v2, weightValue = 1.0)
graph.addUnDirectedEdge(fromVertex = v2, toVertex = v3, weightValue = 1.0)
graph.addUnDirectedEdge(fromVertex = v3, toVertex = v4, weightValue = 4.5)
graph.addUnDirectedEdge(fromVertex = v4, toVertex = v1, weightValue = 2.8)
graph.addUnDirectedEdge(fromVertex = v2, toVertex = v5, weightValue = 3.2)
如果是未加权图，weight 这个参数我们可以不用传递值。
邻接列表的实现
为了维护邻接列表，需要一个类（EdgeList）将边列表映射到一个顶点。然后图只需要简单的维护这样一个对象（EdgeList）的列表就可以，并根据需要修改这个列表。
class EdgeList<T> (var vertex: Vertex<T> ){
var edges: ArrayList<Edge<T>> = ArrayList()
fun addEdge(edge: Edge<T>){
edges.add(edge)
}
}
Graph 的完整实现：
class Graph<T>(private val vertices: ArrayList<Vertex<T>> = ArrayList(),
private val adjacencyList: ArrayList<EdgeList<T>> = ArrayList()) {
fun createVertex(value: T): Vertex<T> {
val matchingVertices = vertices.filter { it.data == value }
if (matchingVertices.isNotEmpty()) {
return matchingVertices.last()
}
val vertex = Vertex(value, adjacencyList.size)
vertices.add(vertex)
adjacencyList.add(EdgeList(vertex))
return vertex
}
fun addDirectedEdge(fromVertex: Vertex<T>, toVertex: Vertex<T>, weightValue: Double) {
val edge = Edge(from = fromVertex,
to = toVertex,
weight = weightValue)
fromVertex.addEdge(edge)
val fromIndex = vertices.indexOf(fromVertex)
adjacencyList[fromIndex].edges.add(edge)
}
fun addUnDirectedEdge(fromVertex: Vertex<T>, toVertex: Vertex<T>, weightValue: Double = 0.0) {
addDirectedEdge(fromVertex, toVertex, weightValue)
addDirectedEdge(toVertex, fromVertex, weightValue)
}
fun printAdjacencyList() {
(0 until vertices.size)
.filterNot { adjacencyList[it].edges.isEmpty() }
.forEach { println("""${vertices[it].data} ->[${adjacencyList[it].edges.joinToString()}] """) }
}
}
来测试一下上面的那个航线图：
val planeGraph = Graph<String>()
val hk = planeGraph.createVertex("Hong Kong")
val ny = planeGraph.createVertex("New York")
val mosc = planeGraph.createVertex("Moscow")
val ld = planeGraph.createVertex("London")
val pairs = planeGraph.createVertex("Pairs")
val am = planeGraph.createVertex("Amsterdam")
val sf = planeGraph.createVertex("San Francisco")
val ja = planeGraph.createVertex("Juneau Alaska")
val tm = planeGraph.createVertex("Timbuktu")
planeGraph.addUnDirectedEdge(hk, sf, 500.0)
planeGraph.addUnDirectedEdge(hk,mosc,900.0)
planeGraph.addDirectedEdge(sf, ja, 300.0)
planeGraph.addUnDirectedEdge(sf, ny, 150.0)
planeGraph.addDirectedEdge(mosc,ny, 750.0)
planeGraph.addDirectedEdge(ld, mosc, 200.0)
planeGraph.addUnDirectedEdge(ld, pairs, 70.0)
planeGraph.addDirectedEdge(sf,pairs, 800.0)
planeGraph.addUnDirectedEdge(pairs, tm, 250.0)
planeGraph.addDirectedEdge(am, pairs, 50.0)
planeGraph.printAdjacencyList()
运行结果如下：
Hong Kong ->[(San Francisco: 500.0), (Moscow: 900.0)]
Moscow ->[(New York: 750.0)]
London ->[(Moscow: 200.0), (Pairs: 70.0)]
Pairs ->[(Timbuktu: 250.0)]
Amsterdam ->[(Pairs: 50.0)]
San Francisco ->[(Juneau Alaska: 300.0), (New York: 150.0), (Pairs: 800.0)]
网友评论