java 图 算法,数据结构-图 的JAVA实现(上)

数据结构--图 的JAVA实现(上)

1，摘要：

本系列文章主要学习如何使用JAVA语言以邻接表的方式实现了数据结构---图(Graph)，这是第一篇文章，学习如何用JAVA来表示图的顶点。从数据的表示方法来说，有二种表示图的方式：一种是邻接矩阵，其实是一个二维数组；一种是邻接表，其实是一个顶点表，每个顶点又拥有一个边列表。下图是图的邻接表表示。

从图中可以看出，图的实现需要能够表示顶点表，能够表示边表。邻接表指是的哪部分呢？每个顶点都有一个邻接表，一个指定顶点的邻接表中，起始顶点表示边的起点，其他顶点表示边的终点。这样，就可以用邻接表来实现边的表示了。如顶点V0的邻接表如下：

与V0关联的边有三条，因为V0的邻接表中有三个顶点(不考虑V0)。

2，具体分析

先来分析边表：

在图中如何来表示一条边？很简单，就是：起始顶点指向结束顶点、就是顶点对。在这里，为了考虑边带有权值的情况，单独设计一个类Edge.java，作为Vertex.java的内部类，Edge.java如下：

1 protected class Edge implementsjava.io.Serializable {2 private VertexInterface vertex;//终点

3 private double weight;//权值

Edge类中只有两个属性，vertex 用来表示顶点，该顶点是边的终点。weight 表示边的权值。若不考虑带权的情况，就不需要weight属性，那么可以直接定义一个顶点列表 来存放 终点 就可以表示边了。这是因为：这些属性是定义在Vertex.java四，而Vertex本身就表示顶点，如果在Vertex内部定义一个List存放终点，那么该List再加上Vertex所表示的顶点本身，就可以表示边了。这样的边的特点是：边的所有的起始点都相同。

但是为了表示带权的边，因此，新增加weight属性，并用类Edge来封装，这样不管是带权的边还是不带权的边都可以用同一个Edge类来表示。不带权的边将weight赋值为0即可。

再分析顶点表：

定义接口VertexInterface表示顶点的接口，所有的顶点都需要实现这个接口，该接口中定义了顶点的基本操作，如：判断顶点是否有邻接点，将顶点与另一个顶点连接起来...。其次，顶点表中的每个顶点有两个域，一个是标识域：V0,V1,V2,V3 。一个是指针域，指针域指向一个"单链表"。综上，设计一个类Vertex.java 用来表示顶点，其数据域如下：

class Vertex implements VertexInterface, java.io.Serializable {private T label;//标识标点,可以用不同类型来标识顶点如String,Integer....

private List edgeList;//到该顶点邻接点的边,实际以java.util.LinkedList存储

private boolean visited;//标识顶点是否已访问

private VertexInterface previousVertex;//该顶点的前驱顶点

private double cost;//顶点的权值,与边的权值要区别开来

现在一一解释Vertex类中定义的各个属性：

label : 用来标识顶点，如图中的 V0,V1,V2,V3，在实际代码中，V0...V3 以字符串的形式表示，就可以用来标识不同的顶点了。因此，需要在Vertex类中添加获得顶点标识的方法---getLabel()

1 publicT getLabel() {2 returnlabel;3 }

edgeList : 存放与该顶点关联的边。从上面Edge.java中可以看到，Edge的实质是“顶点”，因为，Edge类除去wight属性，就只剩表示顶点的vertex属性了。借助edgeList，当给定一个顶点时，就可以访问该顶点的所有邻接点。因此，Vertex.java中就需要实现根据edgeList中存放的边来遍历 某条边的终点(也即相应顶点的各个邻接点) 的迭代器了。

1 public Iterator>getNeighborInterator() {2 return newNeighborIterator();3 }

迭代器的实现如下：

1 /**Task: 遍历该顶点邻接点的迭代器--为 getNeighborInterator()方法 提供迭代器2 * 由于顶点的邻接点以边的形式存储在java.util.List中,因此借助List的迭代器来实现3 * 由于顶点的邻接点由Edge类封装起来了--见Edge.java的定义的第一个属性4 * 因此，首先获得遍历Edge对象的迭代器,再根据获得的Edge对象解析出邻接点对象5 */

6 private class NeighborIterator implements Iterator>{7

8 IteratoredgesIterator;9 privateNeighborIterator() {10 edgesIterator = edgeList.iterator();//获得遍历edgesList 的迭代器

11 }12 @Override13 public booleanhasNext() {14 returnedgesIterator.hasNext();15 }16

17 @Override18 public VertexInterfacenext() {19 VertexInterface nextNeighbor = null;20 if(edgesIterator.hasNext()){21 Edge edgeToNextNeighbor = edgesIterator.next();//LinkedList中存储的是Edge

22 nextNeighbor = edgeToNextNeighbor.getEndVertex();//从Edge对象中取出顶点

23 }24 else

25 throw newNoSuchElementException();26 returnnextNeighbor;27 }28

29 @Override30 public voidremove() {31 throw newUnsupportedOperationException();32 }33 }

visited : 之所以给每个顶点设置一个用来标记它是否被访问的属性，是因为：实现一个数据结构，是要用它去完成某些功能的，如遍历、查找…… 而在图的遍历过程中，就需要标记某个顶点是否被访问了，因此：设置该属性以便实现这些功能。那么，也就需要定义获取顶点是否被访问的isVisited()方法了。

1 public booleanisVisited() {2 returnvisited;3 }

previousVertex 属性 ，在求图中某两个顶点之间的最短路径时，在从起始顶点遍历过程中，需要记录下遍历到某个顶点时的前驱顶点， previousVertex 属性就派上用场了。因此，需要有判断和获取顶点的前驱顶点的方法：

1 public booleanhasPredecessor() {//判断顶点是否有前驱顶点2 return this.previousVertex != null;3 }

1 public VertexInterfacegetPredecessor() {//获得前驱顶点2 return this.previousVertex;3 }

cost 属性：用来表示顶点的权值。注意，顶点的权值与边的权值是不同的。比如求无权图(默认是边不带权值)的最短路径时，如何求出顶点A到顶点B的最短的路径？由定义，该最短路径其实就是A走到B经历的最少边数目。因此，就可以用 cost 属性来记录A到B之间的距离是多少了。比如说，A 先走到 C 再走到B；初始时，A的 cost = 0，由于 A 是 C 的前驱，A到B需要经历C，C 的 cost 就是 c.previousVertex.cost + 1，直至 B，就可以求出 A 到 B 的最短路径了。详细算法及实现将会在第二篇博客中给出。

因此，针对 cost 属性，Vertex.java需要实现的方法如下：

1 public void setCost(doublenewCost) {2 cost =newCost;3 }4 public doublegetCost() {5 returncost;6 }

3，总结：

从上可以看出，设计一个数据结构时，该数据结构需要包含哪些属性不是随意的，而是先确定该数据结构需要完成哪些功能(如，图的DFS、BFS、拓扑排序、最短路径)，这些功能的实现需要借助哪些属性(如，求最短路径需要记录每个顶点的前驱顶点，就需要 previousVertex)。然后，去定义这些属性以及关于该属性的基本操作。设计一个合适的数据结构，当借助该数据结构来实现算法时，可以有效地降低算法的实现难度和复杂度！

Vertex.java的完整代码如下：

1 packagegraph;2

3 importjava.util.Iterator;4 importjava.util.LinkedList;5 importjava.util.List;6 importjava.util.NoSuchElementException;7

8 class Vertex implements VertexInterface, java.io.Serializable {9

10 private T label;//标识标点,可以用不同类型来标识顶点如String,Integer....

11 private List edgeList;//到该顶点邻接点的边,实际以java.util.LinkedList存储

12 private boolean visited;//标识顶点是否已访问

13 private VertexInterface previousVertex;//该顶点的前驱顶点

14 private double cost;//顶点的权值,与边的权值要区别开来

15

16 publicVertex(T vertexLabel){17 label =vertexLabel;18 edgeList = new LinkedList();//是Vertex的属性,说明每个顶点都有一个edgeList用来存储所有与该顶点关系的边

19 visited = false;20 previousVertex = null;21 cost = 0;22 }23

24 /**

25 *Task: 这里用了一个单独的类来表示边,主要是考虑到带权值的边26 *可以看出,Edge类封装了一个顶点和一个double类型变量27 *若不需要考虑权值,可以不需要单独创建一个Edge类来表示边,只需要一个保存顶点的列表即可28 *@authorhapjin29 */

30 protected class Edge implementsjava.io.Serializable {31 private VertexInterface vertex;//终点

32 private double weight;//权值33

34 //Vertex 类本身就代表顶点对象,因此在这里只需提供 endVertex，就可以表示一条边了

35 protected Edge(VertexInterface endVertex, doubleedgeWeight){36 vertex =endVertex;37 weight =edgeWeight;38 }39

40 protected VertexInterfacegetEndVertex(){41 returnvertex;42 }43 protected doublegetWeight(){44 returnweight;45 }46 }47

48 /**Task: 遍历该顶点邻接点的迭代器--为 getNeighborInterator()方法 提供迭代器49 * 由于顶点的邻接点以边的形式存储在java.util.List中,因此借助List的迭代器来实现50 * 由于顶点的邻接点由Edge类封装起来了--见Edge.java的定义的第一个属性51 * 因此，首先获得遍历Edge对象的迭代器,再根据获得的Edge对象解析出邻接点对象52 */

53 private class NeighborIterator implements Iterator>{54

55 IteratoredgesIterator;56 privateNeighborIterator() {57 edgesIterator = edgeList.iterator();//获得遍历edgesList 的迭代器

58 }59 @Override60 public booleanhasNext() {61 returnedgesIterator.hasNext();62 }63

64 @Override65 public VertexInterfacenext() {66 VertexInterface nextNeighbor = null;67 if(edgesIterator.hasNext()){68 Edge edgeToNextNeighbor = edgesIterator.next();//LinkedList中存储的是Edge

69 nextNeighbor = edgeToNextNeighbor.getEndVertex();//从Edge对象中取出顶点

70 }71 else

72 throw newNoSuchElementException();73 returnnextNeighbor;74 }75

76 @Override77 public voidremove() {78 throw newUnsupportedOperationException();79 }80 }81

82 /**Task: 生成一个遍历该顶点所有邻接边的权值的迭代器83 * 权值是Edge类的属性,因此先获得一个遍历Edge对象的迭代器,取得Edge对象,再获得权值84 *@authorhapjin85 *86 *@param 权值的类型87 */

88 private class WeightIterator implements Iterator{//这里不知道为什么,用泛型报编译错误???

89

90 private IteratoredgesIterator;91 privateWeightIterator(){92 edgesIterator =edgeList.iterator();93 }94 @Override95 public booleanhasNext() {96 returnedgesIterator.hasNext();97 }98 @Override99 publicObject next() {100 Double result;101 if(edgesIterator.hasNext()){102 Edge edge =edgesIterator.next();103 result =edge.getWeight();104 }105 else throw newNoSuchElementException();106 return (Object)result;//从迭代器中取得结果时,需要强制转换成Double

107 }108 @Override109 public voidremove() {110 throw newUnsupportedOperationException();111 }112

113 }114

115 @Override116 publicT getLabel() {117 returnlabel;118 }119

120 @Override121 public voidvisit() {122 this.visited = true;123 }124

125 @Override126 public voidunVisit() {127 this.visited = false;128 }129

130 @Override131 public booleanisVisited() {132 returnvisited;133 }134

135 @Override136 public boolean connect(VertexInterface endVertex, doubleedgeWeight) {137 //将"边"(边的实质是顶点)插入顶点的邻接表

138 boolean result = false;139 if(!this.equals(endVertex)){//顶点互不相同

140 Iterator> neighbors = this.getNeighborInterator();141 boolean duplicateEdge = false;142 while(!duplicateEdge && neighbors.hasNext()){//保证不添加重复的边

143 VertexInterface nextNeighbor =neighbors.next();144 if(endVertex.equals(nextNeighbor)){145 duplicateEdge = true;146 break;147 }148 }//end while

149 if(!duplicateEdge){150 edgeList.add(new Edge(endVertex, edgeWeight));//添加一条新边

151 result = true;152 }//end if

153 }//end if

154 returnresult;155 }156

157 @Override158 public boolean connect(VertexInterfaceendVertex) {159 return connect(endVertex, 0);160 }161

162 @Override163 public Iterator>getNeighborInterator() {164 return newNeighborIterator();165 }166

167 @Override168 publicIterator getWeightIterator() {169 return newWeightIterator();170 }171

172 @Override173 public booleanhasNeighbor() {174 return !(edgeList.isEmpty());//邻接点实质是存储是List中

175 }176

177 @Override178 public VertexInterfacegetUnvisitedNeighbor() {179 VertexInterface result = null;180 Iterator> neighbors =getNeighborInterator();181 while(neighbors.hasNext() && result == null){//获得该顶点的第一个未被访问的邻接点

182 VertexInterface nextNeighbor =neighbors.next();183 if(!nextNeighbor.isVisited())184 result =nextNeighbor;185 }186 returnresult;187 }188

189 @Override190 public void setPredecessor(VertexInterfacepredecessor) {191 this.previousVertex =predecessor;192 }193

194 @Override195 public VertexInterfacegetPredecessor() {196 return this.previousVertex;197 }198

199 @Override200 public booleanhasPredecessor() {201 return this.previousVertex != null;202 }203

204 @Override205 public void setCost(doublenewCost) {206 cost =newCost;207 }208

209 @Override210 public doublegetCost() {211 returncost;212 }213

214 //判断两个顶点是否相同

215 public booleanequals(Object other){216 booleanresult;217 if((other == null) || (getClass() !=other.getClass()))218 result = false;219 else

220 {221 Vertex otherVertex = (Vertex)other;222 result = label.equals(otherVertex.label);//节点是否相同最终还是由标识 节点类型的类的equals() 决定

223 }224 returnresult;225 }226 }