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

时间 2019-11-14

标签数据结构 java 实现栏目 Java 繁體版

原文原文链接

1，摘要：java

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

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

与V0关联的边有三条，由于V0的邻接表中有三个顶点(不考虑V0)。数据结构

2，具体分析ide

先来分析边表：学习

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

1 protected class Edge implements java.io.Serializable {
2         private VertexInterface<T> vertex;// 终点
3         private double weight;//权值

Edge类中只有两个属性，vertex 用来表示顶点，该顶点是边的终点。weight 表示边的权值。若不考虑带权的状况，就不须要weight属性，那么能够直接定义一个顶点列表来存放终点就能够表示边了。这是由于：这些属性是定义在Vertex.java中，而Vertex自己就表示顶点，若是在Vertex内部定义一个List存放终点，那么该List再加上Vertex所表示的顶点自己，就能够表示与起点邻接的各个点了（称之为这个起点的邻接表）。这样的边的特色是：边的全部的起始点都相同。spa

可是为了表示带权的边，所以，新增长weight属性，并用类Edge来封装，这样不论是带权的边仍是不带权的边均可以用同一个Edge类来表示。不带权的边将weight赋值为0便可。设计

再分析顶点表：指针

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

class Vertex<T> implements VertexInterface<T>, java.io.Serializable {

    private T label;//标识标点,能够用不一样类型来标识顶点如String,Integer....
    private List<Edge> edgeList;//到该顶点邻接点的边,实际以java.util.LinkedList存储
    private boolean visited;//标识顶点是否已访问
    private VertexInterface<T> previousVertex;//该顶点的前驱顶点
    private double cost;//顶点的权值,与边的权值要区别开来

如今一一解释Vertex类中定义的各个属性：

label : 用来标识顶点，如图中的 V0,V1,V2,V3，在实际代码中，V0...V3 以字符串的形式表示，就能够用来标识不一样的顶点了。所以，须要在Vertex类中添加得到顶点标识的方法---getLabel()

1     public T getLabel() {
2         return label;
3     }

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

1 public Iterator<VertexInterface<T>> getNeighborInterator() {
2         return new NeighborIterator();
3     }

迭代器的实现以下：

 1 /**Task: 遍历该顶点邻接点的迭代器--为 getNeighborInterator()方法 提供迭代器
 2      * 因为顶点的邻接点以边的形式存储在java.util.List中,所以借助List的迭代器来实现
 3      * 因为顶点的邻接点由Edge类封装起来了--见Edge.java的定义的第一个属性
 4      * 所以，首先得到遍历Edge对象的迭代器,再根据得到的Edge对象解析出邻接点对象
 5      */
 6     private class NeighborIterator implements Iterator<VertexInterface<T>>{
 7 
 8         Iterator<Edge> edgesIterator;
 9         private NeighborIterator() {
10             edgesIterator = edgeList.iterator();//得到遍历edgesList 的迭代器
11         }
12         @Override
13         public boolean hasNext() {
14             return edgesIterator.hasNext();
15         }
16 
17         @Override
18         public VertexInterface<T> next() {
19             VertexInterface<T> nextNeighbor = null;
20             if(edgesIterator.hasNext()){
21                 Edge edgeToNextNeighbor = edgesIterator.next();//LinkedList中存储的是Edge
22                 nextNeighbor = edgeToNextNeighbor.getEndVertex();//从Edge对象中取出顶点
23             }
24             else
25                 throw new NoSuchElementException();
26             return nextNeighbor;
27         }
28 
29         @Override
30         public void remove() {
31             throw new UnsupportedOperationException();
32         }
33     }

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

1     public boolean isVisited() {
2         return visited;
3     }

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

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

1     public VertexInterface<T> getPredecessor() {//得到前驱顶点
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(double newCost) {
2         cost = newCost;
3     }
4 public double getCost() {
5         return cost;
6     }

3，总结：

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

Vertex.java的完整代码以下：

  1 package graph;
  2 
  3 import java.util.Iterator;
  4 import java.util.LinkedList;
  5 import java.util.List;
  6 import java.util.NoSuchElementException;
  7 
  8 class Vertex<T> implements VertexInterface<T>, java.io.Serializable {
  9 
 10     private T label;//标识标点,能够用不一样类型来标识顶点如String,Integer....
 11     private List<Edge> edgeList;//到该顶点邻接点的边,实际以java.util.LinkedList存储
 12     private boolean visited;//标识顶点是否已访问
 13     private VertexInterface<T> previousVertex;//该顶点的前驱顶点
 14     private double cost;//顶点的权值,与边的权值要区别开来
 15     
 16     public Vertex(T vertexLabel){
 17         label = vertexLabel;
 18         edgeList = new LinkedList<Edge>();//是Vertex的属性,说明每一个顶点都有一个edgeList用来存储全部与该顶点关系的边
 19         visited = false;
 20         previousVertex = null;
 21         cost = 0;
 22     }
 23     
 24     /**
 25      *Task: 这里用了一个单独的类来表示边,主要是考虑到带权值的边
 26      *能够看出,Edge类封装了一个顶点和一个double类型变量 
 27      *若不须要考虑权值,能够不须要单首创建一个Edge类来表示边,只须要一个保存顶点的列表便可
 28      * @author hapjin
 29      */
 30     protected class Edge implements java.io.Serializable {
 31         private VertexInterface<T> vertex;// 终点
 32         private double weight;//权值
 33         
 34         //Vertex 类自己就表明顶点对象,所以在这里只需提供 endVertex，就能够表示一条边了
 35         protected Edge(VertexInterface<T> endVertex, double edgeWeight){
 36             vertex = endVertex;
 37             weight = edgeWeight;
 38         }
 39         
 40         protected VertexInterface<T> getEndVertex(){
 41             return vertex;
 42         }
 43         protected double getWeight(){
 44             return weight;
 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<VertexInterface<T>>{
 54 
 55         Iterator<Edge> edgesIterator;
 56         private NeighborIterator() {
 57             edgesIterator = edgeList.iterator();//得到遍历edgesList 的迭代器
 58         }
 59         @Override
 60         public boolean hasNext() {
 61             return edgesIterator.hasNext();
 62         }
 63 
 64         @Override
 65         public VertexInterface<T> next() {
 66             VertexInterface<T> nextNeighbor = null;
 67             if(edgesIterator.hasNext()){
 68                 Edge edgeToNextNeighbor = edgesIterator.next();//LinkedList中存储的是Edge
 69                 nextNeighbor = edgeToNextNeighbor.getEndVertex();//从Edge对象中取出顶点
 70             }
 71             else
 72                 throw new NoSuchElementException();
 73             return nextNeighbor;
 74         }
 75 
 76         @Override
 77         public void remove() {
 78             throw new UnsupportedOperationException();
 79         }
 80     }
 81     
 82     /**Task: 生成一个遍历该顶点全部邻接边的权值的迭代器
 83      * 权值是Edge类的属性,所以先得到一个遍历Edge对象的迭代器,取得Edge对象,再得到权值
 84      * @author hapjin
 85      *
 86      * @param <Double> 权值的类型
 87      */
 88     private class WeightIterator implements Iterator{//这里不知道为何,用泛型报编译错误???
 89         
 90         private Iterator<Edge> edgesIterator;
 91         private WeightIterator(){
 92             edgesIterator = edgeList.iterator();
 93         }
 94         @Override
 95         public boolean hasNext() {
 96             return edgesIterator.hasNext();
 97         }
 98         @Override
 99         public Object next() {
100             Double result;
101             if(edgesIterator.hasNext()){
102                 Edge edge = edgesIterator.next();
103                 result = edge.getWeight();
104             }
105             else throw new NoSuchElementException();
106             return (Object)result;//从迭代器中取得结果时,须要强制转换成Double
107         }
108         @Override
109         public void remove() {
110             throw new UnsupportedOperationException();
111         }
112         
113     }
114     
115     @Override
116     public T getLabel() {
117         return label;
118     }
119 
120     @Override
121     public void visit() {
122         this.visited = true;
123     }
124 
125     @Override
126     public void unVisit() {
127         this.visited = false;
128     }
129 
130     @Override
131     public boolean isVisited() {
132         return visited;
133     }
134 
135     @Override
136     public boolean connect(VertexInterface<T> endVertex, double edgeWeight) {
137         // 将"边"(边的实质是顶点)插入顶点的邻接表
138         boolean result = false;
139         if(!this.equals(endVertex)){//顶点互不相同
140             Iterator<VertexInterface<T>> neighbors = this.getNeighborInterator();
141             boolean duplicateEdge = false;
142             while(!duplicateEdge && neighbors.hasNext()){//保证不添加剧复的边
143                 VertexInterface<T> 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         return result;
155     }
156 
157     @Override
158     public boolean connect(VertexInterface<T> endVertex) {
159         return connect(endVertex, 0);
160     }
161 
162     @Override
163     public Iterator<VertexInterface<T>> getNeighborInterator() {
164         return new NeighborIterator();
165     }
166 
167     @Override
168     public Iterator getWeightIterator() {
169         return new WeightIterator();
170     }
171 
172     @Override
173     public boolean hasNeighbor() {
174         return !(edgeList.isEmpty());//邻接点实质是存储是List中
175     }
176 
177     @Override
178     public VertexInterface<T> getUnvisitedNeighbor() {
179         VertexInterface<T> result = null;
180         Iterator<VertexInterface<T>> neighbors = getNeighborInterator();
181         while(neighbors.hasNext() && result == null){//得到该顶点的第一个未被访问的邻接点
182             VertexInterface<T> nextNeighbor = neighbors.next();
183             if(!nextNeighbor.isVisited())
184                 result = nextNeighbor;
185         }
186         return result;
187     }
188 
189     @Override
190     public void setPredecessor(VertexInterface<T> predecessor) {
191         this.previousVertex = predecessor;
192     }
193 
194     @Override
195     public VertexInterface<T> getPredecessor() {
196         return this.previousVertex;
197     }
198 
199     @Override
200     public boolean hasPredecessor() {
201         return this.previousVertex != null;
202     }
203 
204     @Override
205     public void setCost(double newCost) {
206         cost = newCost;
207     }
208 
209     @Override
210     public double getCost() {
211         return cost;
212     }
213     
214     //判断两个顶点是否相同
215     public boolean equals(Object other){
216         boolean result;
217         if((other == null) || (getClass() != other.getClass()))
218             result = false;
219         else
220         {
221             Vertex<T> otherVertex = (Vertex<T>)other;
222             result = label.equals(otherVertex.label);//节点是否相同最终仍是由标识 节点类型的类的equals() 决定
223         }
224         return result;
225     }
226 }

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

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