1,摘要:

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

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

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

 2,具体分析

先来分析边表:

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

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

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

但是为了表示带权的边,因此,新增加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()

     public T getLabel() {
return label;
}

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

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

迭代器的实现如下:

 /**Task: 遍历该顶点邻接点的迭代器--为 getNeighborInterator()方法 提供迭代器
* 由于顶点的邻接点以边的形式存储在java.util.List中,因此借助List的迭代器来实现
* 由于顶点的邻接点由Edge类封装起来了--见Edge.java的定义的第一个属性
* 因此,首先获得遍历Edge对象的迭代器,再根据获得的Edge对象解析出邻接点对象
*/
private class NeighborIterator implements Iterator<VertexInterface<T>>{ Iterator<Edge> edgesIterator;
private NeighborIterator() {
edgesIterator = edgeList.iterator();//获得遍历edgesList 的迭代器
}
@Override
public boolean hasNext() {
return edgesIterator.hasNext();
} @Override
public VertexInterface<T> next() {
VertexInterface<T> nextNeighbor = null;
if(edgesIterator.hasNext()){
Edge edgeToNextNeighbor = edgesIterator.next();//LinkedList中存储的是Edge
nextNeighbor = edgeToNextNeighbor.getEndVertex();//从Edge对象中取出顶点
}
else
throw new NoSuchElementException();
return nextNeighbor;
} @Override
public void remove() {
throw new UnsupportedOperationException();
}
}

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

     public boolean isVisited() {
return visited;
}

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

     public boolean hasPredecessor() {//判断顶点是否有前驱顶点
return this.previousVertex != null;
}
     public VertexInterface<T> getPredecessor() {//获得前驱顶点
return this.previousVertex;
}

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需要实现的方法如下:

 public void setCost(double newCost) {
cost = newCost;
}
public double getCost() {
return cost;
}

3,总结:

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

Vertex.java的完整代码如下:

 package graph;

 import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException; 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;//顶点的权值,与边的权值要区别开来 public Vertex(T vertexLabel){
label = vertexLabel;
edgeList = new LinkedList<Edge>();//是Vertex的属性,说明每个顶点都有一个edgeList用来存储所有与该顶点关系的边
visited = false;
previousVertex = null;
cost = 0;
} /**
*Task: 这里用了一个单独的类来表示边,主要是考虑到带权值的边
*可以看出,Edge类封装了一个顶点和一个double类型变量
*若不需要考虑权值,可以不需要单独创建一个Edge类来表示边,只需要一个保存顶点的列表即可
* @author hapjin
*/
protected class Edge implements java.io.Serializable {
private VertexInterface<T> vertex;// 终点
private double weight;//权值 //Vertex 类本身就代表顶点对象,因此在这里只需提供 endVertex,就可以表示一条边了
protected Edge(VertexInterface<T> endVertex, double edgeWeight){
vertex = endVertex;
weight = edgeWeight;
} protected VertexInterface<T> getEndVertex(){
return vertex;
}
protected double getWeight(){
return weight;
}
} /**Task: 遍历该顶点邻接点的迭代器--为 getNeighborInterator()方法 提供迭代器
* 由于顶点的邻接点以边的形式存储在java.util.List中,因此借助List的迭代器来实现
* 由于顶点的邻接点由Edge类封装起来了--见Edge.java的定义的第一个属性
* 因此,首先获得遍历Edge对象的迭代器,再根据获得的Edge对象解析出邻接点对象
*/
private class NeighborIterator implements Iterator<VertexInterface<T>>{ Iterator<Edge> edgesIterator;
private NeighborIterator() {
edgesIterator = edgeList.iterator();//获得遍历edgesList 的迭代器
}
@Override
public boolean hasNext() {
return edgesIterator.hasNext();
} @Override
public VertexInterface<T> next() {
VertexInterface<T> nextNeighbor = null;
if(edgesIterator.hasNext()){
Edge edgeToNextNeighbor = edgesIterator.next();//LinkedList中存储的是Edge
nextNeighbor = edgeToNextNeighbor.getEndVertex();//从Edge对象中取出顶点
}
else
throw new NoSuchElementException();
return nextNeighbor;
} @Override
public void remove() {
throw new UnsupportedOperationException();
}
} /**Task: 生成一个遍历该顶点所有邻接边的权值的迭代器
* 权值是Edge类的属性,因此先获得一个遍历Edge对象的迭代器,取得Edge对象,再获得权值
* @author hapjin
*
* @param <Double> 权值的类型
*/
private class WeightIterator implements Iterator{//这里不知道为什么,用泛型报编译错误??? private Iterator<Edge> edgesIterator;
private WeightIterator(){
edgesIterator = edgeList.iterator();
}
@Override
public boolean hasNext() {
return edgesIterator.hasNext();
}
@Override
public Object next() {
Double result;
if(edgesIterator.hasNext()){
Edge edge = edgesIterator.next();
result = edge.getWeight();
}
else throw new NoSuchElementException();
return (Object)result;//从迭代器中取得结果时,需要强制转换成Double
}
@Override
public void remove() {
throw new UnsupportedOperationException();
} } @Override
public T getLabel() {
return label;
} @Override
public void visit() {
this.visited = true;
} @Override
public void unVisit() {
this.visited = false;
} @Override
public boolean isVisited() {
return visited;
} @Override
public boolean connect(VertexInterface<T> endVertex, double edgeWeight) {
// 将"边"(边的实质是顶点)插入顶点的邻接表
boolean result = false;
if(!this.equals(endVertex)){//顶点互不相同
Iterator<VertexInterface<T>> neighbors = this.getNeighborInterator();
boolean duplicateEdge = false;
while(!duplicateEdge && neighbors.hasNext()){//保证不添加重复的边
VertexInterface<T> nextNeighbor = neighbors.next();
if(endVertex.equals(nextNeighbor)){
duplicateEdge = true;
break;
}
}//end while
if(!duplicateEdge){
edgeList.add(new Edge(endVertex, edgeWeight));//添加一条新边
result = true;
}//end if
}//end if
return result;
} @Override
public boolean connect(VertexInterface<T> endVertex) {
return connect(endVertex, 0);
} @Override
public Iterator<VertexInterface<T>> getNeighborInterator() {
return new NeighborIterator();
} @Override
public Iterator getWeightIterator() {
return new WeightIterator();
} @Override
public boolean hasNeighbor() {
return !(edgeList.isEmpty());//邻接点实质是存储是List中
} @Override
public VertexInterface<T> getUnvisitedNeighbor() {
VertexInterface<T> result = null;
Iterator<VertexInterface<T>> neighbors = getNeighborInterator();
while(neighbors.hasNext() && result == null){//获得该顶点的第一个未被访问的邻接点
VertexInterface<T> nextNeighbor = neighbors.next();
if(!nextNeighbor.isVisited())
result = nextNeighbor;
}
return result;
} @Override
public void setPredecessor(VertexInterface<T> predecessor) {
this.previousVertex = predecessor;
} @Override
public VertexInterface<T> getPredecessor() {
return this.previousVertex;
} @Override
public boolean hasPredecessor() {
return this.previousVertex != null;
} @Override
public void setCost(double newCost) {
cost = newCost;
} @Override
public double getCost() {
return cost;
} //判断两个顶点是否相同
public boolean equals(Object other){
boolean result;
if((other == null) || (getClass() != other.getClass()))
result = false;
else
{
Vertex<T> otherVertex = (Vertex<T>)other;
result = label.equals(otherVertex.label);//节点是否相同最终还是由标识 节点类型的类的equals() 决定
}
return result;
}
}

数据结构--图 的JAVA实现(上)的更多相关文章

  1. 数据结构--图 的JAVA实现(下)

    在上一篇文章中记录了如何实现图的邻接表.本文借助上一篇文章实现的邻接表来表示一个有向无环图. 1,概述 图的实现与邻接表的实现最大的不同就是,图的实现需要定义一个数据结构来存储所有的顶点以及能够对图进 ...

  2. 数据结构 -- 图的最短路径 Java版

    作者版权所有,转载请注明出处,多谢.http://www.cnblogs.com/Henvealf/p/5574455.html 上一篇介绍了有关图的表示和遍历实现.数据结构 -- 简单图的实现与遍历 ...

  3. java数据结构----图

    1.图:.在计算机程序设计中,图是最常用的数据结构之一.对于存储一般的数据问题,一般用不到图.但对于某些(特别是一些有趣的问题),图是必不可少的.图是一种与树有些相像的数据结构,从数学意义上来讲,树是 ...

  4. 一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库 RxJava,相当好

    https://github.com/ReactiveX/RxJava https://github.com/ReactiveX/RxAndroid RX (Reactive Extensions,响 ...

  5. 深入理解Java虚拟机--上

    深入理解Java虚拟机--上 第2章 Java内存区域和内存溢出异常 2.2 运行时数据区域 图 2-1 Java虚拟机运行时数据区 2.2.1 程序计数器 程序计数器可以看作是当前线程所执行的字节码 ...

  6. 数据结构与抽象 Java语言描述 第4版 pdf (内含标签)

    数据结构与抽象 Java语言描述 第4版 目录 前言引言组织数据序言设计类P.1封装P.2说明方法P.2.1注释P.2.2前置条件和后置条件P.2.3断言P.3Java接口P.3.1写一个接口P.3. ...

  7. 【Java心得总结五】Java容器上——容器初探

    在数学中我们有集合的概念,所谓的一个集合,就是将数个对象归类而分成为一个或数个形态各异的大小整体. 一般来讲,集合是具有某种特性的事物的整体,或是一些确认对象的汇集.构成集合的事物或对象称作元素或是成 ...

  8. IntelliJ IDEA 工程Java文件上红色的无效符

    IntelliJ IDEA 工程Java文件上红色的无效符(红色表示该类是不可编译文件) 1.查看Java.resources文件夹 如图所示,是因为没有配置 2.在Java文件夹点击右键找到Mark ...

  9. 将linux上的Java代码上传到码云

    将linux上的Java代码上传到码云 1.在linux上直接输入命令获取git sudo apt-get install git 显示资源被占用,按照图中方法强制安装 2.建立与教材配套的目录结构 ...

随机推荐

  1. nginx之请求限制与连接限制

    模块limit_conn_module与limit_req_module limit_conn_module语法 limit_req_module语法 附: http长连接与短连接

  2. linux之各目录作用

    /opt目录 目录用来安装附加软件包,用户调用软件包程序放在目录/opt/package_name/bin下,package_name是安装软件包的名称 /etc目录 是用来放一些核心的配置文件 附各 ...

  3. vue.js----之router详解(一)

    在vue1.0版本的超链接标签还是原来的a标签,链接地址由v-link属性控制 而vue2.0版本里超链接标签由a标签被替换成了router-link标签,但最终在页面还是会被渲染成a标签的 至于为什 ...

  4. Spark Streaming 实现思路与模块概述

    一.基于 Spark 做 Spark Streaming 的思路 Spark Streaming 与 Spark Core 的关系可以用下面的经典部件图来表述: 在本节,我们先探讨一下基于 Spark ...

  5. 3790:最短路径问题(HDU)

    Problem Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的.   Inp ...

  6. LeetCode(123):买卖股票的最佳时机 III

    Hard! 题目描述: 给定一个数组,它的第 i 个元素是一支给定的股票在第 i 天的价格. 设计一个算法来计算你所能获取的最大利润.你最多可以完成 两笔 交易. 注意: 你不能同时参与多笔交易(你必 ...

  7. tail -f -n 0 /var/log/messages

    <pre><font color="#CC0000"><b>root@kali</b></font>:<font ...

  8. PyCharm设置字体风格

    设置字体风格:File—Setting—Editor-Color Scheme-Color Scheme Font-把Scheme设置为:WarmNeon

  9. JS实现继承的几种方式(转)

    转自:幻天芒的博客 前言 JS作为面向对象的弱类型语言,继承也是其非常强大的特性之一.那么如何在JS中实现继承呢?让我们拭目以待. JS继承的实现方式 既然要实现继承,那么首先我们得有一个父类,代码如 ...

  10. selenium 无法启动IE

    解决办法是IE选项设置的安全页中,4个区域的启用保护模式的勾选都去掉(或都勾上)