定义：
    计算机视觉是使用计算机及相关设备对生物视觉的一种模拟。它的主要任务就是通过对采集的图片或视频进行处理以获得相应场景的三维信息，就像人类和许多其他类生物每天所做的那样。
    计算机视觉是一门关于如何运用照相机和计算机来获取我们所需的，被拍摄对象的数据与信息的学问。形象地说，就是给计算机安装上眼睛（照相机）和大脑（算法），让计算机能够感知环境。我们中国人的成语"眼见为实"和西方人常说的"One picture is worth ten thousand words"表达了视觉对人类的重要性。不难想象，具有视觉的机器的应用前景能有多么地宽广。
    计算机视觉既是工程领域，也是科学领域中的一个富有挑战性重要研究领域。计算机视觉是一门综合性的学科，它已经吸引了来自各个学科的研究者参加到对它的研究之中。其中包括计算机科学和工程、信号处理、物理学、应用数学和统计学，神经生理学和认知科学等。

原理：

    计算机视觉就是用各种成象系统代替视觉器官作为输入敏感手段，由计算机来代替大脑完成处理和解释。计算机视觉的最终研究目标就是使计算机能象人那样通过视觉观察和理解世界，具有自主适应环境的能力。要经过长期的努力才能达到的目标。因此，在实现最终目标以前，人们努力的中期目标是建立一种视觉系统，这个系统能依据视觉敏感和反馈的某种程度的智能完成一定的任务。例如，计算机视觉的一个重要应用领域就是自主车辆的视觉导航，还没有条件实现象人那样能识别和理解任何环境，完成自主导航的系统。因此，人们努力的研究目标是实现在高速公路上具有道路跟踪能力，可避免与前方车辆碰撞的视觉辅助驾驶系统。这里要指出的一点是在计算机视觉系统中计算机起代替人脑的作用，但并不意味着计算机必须按人类视觉的方法完成视觉信息的处理。计算机视觉可以而且应该根据计算机系统的特点来进行视觉信息的处理。但是，人类视觉系统是迄今为止，人们所知道的功能最强大和完善的视觉系统。如在以下的章节中会看到的那样，对人类视觉处理机制的研究将给计算机视觉的研究提供启发和指导。因此，用计算机信息处理的方法研究人类视觉的机理，建立人类视觉的计算理论，也是一个非常重要和信人感兴趣的研究领域。这方面的研究被称为计算视觉（Computational
 Vision）。计算视觉可被认为是计算机视觉中的一个研究领域。

目前应用： 

    人类正在进入信息时代，计算机将越来越广泛地进入几乎所有领域。一方面是更多未经计算机专业训练的人也需要应用计算机，而另一方面是计算机的功能越来越强，使用方法越来越复杂。这就使人在进行交谈和通讯时的灵活性与在使用计算机时所要求的严格和死板之间产生了尖锐的矛盾。人可通过视觉和听觉，语言与外界交换信息，并且可用不同的方式表示相同的含义，而计算机却要求严格按照各种程序语言来编写程序，只有这样计算机才能运行。为使更多的人能使用复杂的计算机，必须改变过去的那种让人来适应计算机，来死记硬背计算机的使用规则的情况。而是反过来让计算机来适应人的习惯和要求，以人所习惯的方式与人进行信息交换，也就是让计算机具有视觉、听觉和说话等能力。这时计算机必须具有逻辑推理和决策的能力。具有上述能力的计算机就是智能计算机。
    智能计算机不但使计算机更便于为人们所使用，同时如果用这样的计算机来控制各种自动化装置特别是智能机器人，就可以使这些自动化系统和智能机器人具有适应环境，和自主作出决策的能力。这就可以在各种场合取代人的繁重工作，或代替人到各种危险和恶劣环境中完成任务。
    应用范围从任务，比如工业机器视觉系统，比方说，检查瓶子上的生产线加速通过，研究为人工智能和计算机或机器人，可以理解他们周围的世界。计算机视觉和机器视觉领域有显著的重叠。计算机视觉涉及的被用于许多领域自动化图像分析的核心技术。机器视觉通常指的是结合自动图像分析与其他方法和技术，以提供自动检测和机器人指导在工业应用中的一个过程。在许多计算机视觉应用中，计算机被预编程，以解决特定的任务，但基于学习的方法现在正变得越来越普遍。计算机视觉应用的实例包括用于系统：
（1）控制过程，比如，一个工业机器人 ；
（2）导航，例如，通过自主汽车或移动机器人；
（3）检测的事件，如，对视频监控和人数统计 ；
（4）组织信息，例如，对于图像和图像序列的索引数据库；
（5）造型对象或环境，如，医学图像分析系统或地形模型；
（6）相互作用，例如，当输入到一个装置，用于计算机人的交互；
（7）自动检测，例如，在制造业的应用程序。
    其中最突出的应用领域是医疗计算机视觉和医学图像处理。这个区域的特征的信息从图像数据中提取用于使患者的医疗诊断的目的。通常，图像数据是在形式显微镜图像，X射线图像，血管造影图像，超声图像和断层图像。的信息，可以从这样的图像数据中提取的一个例子是检测的肿瘤，动脉粥样硬化或其他恶性变化。它也可以是器官的尺寸，血流量等。这种应用领域还支持通过提供新的信息，医学研究的测量例如，对脑的结构，或约医学治疗的质量。计算机视觉在医疗领域的应用还包括增强是由人类的解释，例如超声图像或X射线图像，以降低噪声的影响的图像。
    第二个应用程序区域中的计算机视觉是在工业，有时也被称为机器视觉，在那里信息被提取为支撑的制造工序的目的。一个例子是质量控制，其中的信息或最终产品被以找到缺陷自动检测。另一个例子是，被拾取的位置和细节取向测量由机器人臂。机器视觉也被大量用于农业的过程，从散装材料，这个过程被称为去除不想要的东西，食物的光学分拣。
军事上的应用很可能是计算机视觉最大的地区之一。最明显的例子是探测敌方士兵或车辆和导弹制导。更先进的系统为导弹制导发送导弹的区域，而不是一个特定的目标，并且当导弹到达基于本地获取的图像数据的区域的目标做出选择。现代军事概念，如“战场感知”，意味着各种传感器，包括图像传感器，提供了丰富的有关作战的场景，可用于支持战略决策的信息。在这种情况下，数据的自动处理，用于减少复杂性和融合来自多个传感器的信息，以提高可靠性。
    一个较新的应用领域是自主车，其中包括潜水，陆上车辆（带轮子，轿车或卡车的小机器人），高空作业车和无人机（UAV）。自主化水平，从完全独立的（无人）的车辆范围为汽车，其中基于计算机视觉的系统支持驱动程序或在不同情况下的试验。完全自主的汽车通常使用计算机视觉进行导航时，即知道它在哪里，或用于生产的环境（地图SLAM）和用于检测障碍物。它也可以被用于检测特定任务的特定事件，例如，一个UAV寻找森林火灾。支承系统的例子是障碍物警报系统中的汽车，以及用于飞行器的自主着陆系统。数家汽车制造商已经证明了系统的汽车自动驾驶，但该技术还没有达到一定的水平，就可以投放市场。有军事自主车型，从先进的导弹，无人机的侦察任务或导弹的制导充足的例子。太空探索已经正在使用计算机视觉，自主车比如，美国宇航局的火星探测漫游者和欧洲航天局的ExoMars火星漫游者。
    其他应用领域包括：
（1）支持视觉特效制作的电影和广播，例如，摄像头跟踪（运动匹配）。
（2）监视。

计算机视觉整个系统：


    计算机视觉系统的结构形式很大程度上依赖于其具体应用方向。有些是独立工作的，用于解决具体的测量或检测问题；也有些作为某个大型复杂系统的组成部分出现，比如和机械控制系统，数据库系统，人机接口设备协同工作。计算机视觉系统的具体实现方法同时也由其功能决定——是预先固定的抑或是在运行过程中自动学习调整。尽管如此，有些功能却几乎是每个计算机系统都需要具备的：


图像获取

一幅数字图像是由一个或多个图像感知器产生，这里的感知器可以是各种光敏摄像机，包括遥感设备，X射线断层摄影仪，雷达，超声波接收器等。取决于不同的感知器，产生的图片可以是普通的二维图像，三维图组或者一个图像序列。图片的像素值往往对应于光在一个或多个光谱段上的强度（灰度图或彩色图），但也可以是相关的各种物理数据，如声波，电磁波或核磁共振的深度，吸收度或反射度。


预处理
在对图像实施具体的计算机视觉方法来提取某种特定的信息前，一种或一些预处理往往被采用来使图像满足后继方法的要求。例如：
二次取样保证图像坐标的正确；
平滑去噪来滤除感知器引入的设备噪声；
提高对比度来保证实现相关信息可以被检测到；

调整尺度空间使图像结构适合局部应用。


特征提取
从图像中提取各种复杂度的特征。例如：
线，边缘提取；
局部化的特征点检测如边角检测，斑点检测；

更复杂的特征可能与图像中的纹理形状或运动有关。


检测分割
在图像处理过程中，有时会需要对图像进行分割来提取有价值的用于后继处理的部分，例如
筛选特征点；

分割一或多幅图片中含有特定目标的部分。


高级处理
到了这一步，数据往往具有很小的数量，例如图像中经先前处理被认为含有目标物体的部分。这时的处理包括：
验证得到的数据是否符合前提要求；
估测特定系数，比如目标的姿态，体积；
对目标进行分类。

高级处理有理解图像内容的含义，是计算机视觉中的高阶处理，主要是在图像分割的基础上再经行对分割出的图像块进行理解，例如进行识别等操作。


原文地址：http://www.peileyuan.com/topics/296

                    java图的邻接表实现两种方式及实例应用分析


本篇博客来谈一谈图的邻接表实现的两种方式，首先我们明确一点“学会图的邻接表实现的关键点在于“：你所建立的图的邻接表的对象是什么！

首先我们看一下《算法导论》中关于图的邻接表的定义：图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成，其中每个列表对应于V中的一个顶点，对于每一个u∈V，邻接表Adj[u]包含所有满足条件（u，v）∈E的顶点v，亦即，Adj[u]包含图G中所有和顶点u相邻的顶点。（或者他也可能指向这些顶点的指针），每个邻接表中的顶点一般以任意的顺序存储。（注意一下这句话！）

图的邻接表表示如下图所示： 





定义总是比较晦涩难懂的，下面我们从如何实现图的邻接表表示来谈一谈！ 
1、邻接表构建图是必须需要一个Graph对象，也就是图对象！该对象包含属性有：顶点数、边数以及图的顶点集合；

2、正如上面所说，邻接链表的对象首先我们需要确定邻接表的对象，可以用顶点作为邻接链表的对象，自然也可以用边作为邻接链表的对象！下面将分别对这两种方式进行讲解！

一、邻接链表使用顶点作为对象构建图

1、Graph对象类
/**
 * 自定义图类
 * @author King
 */
public class Graph1 {
    Vertex1[] vertexArray=new Vertex1[100];
    int verNum=0;
    int edgeNum=0;
}
1
2
3
4
5
6
7
8
9

2、Vertex对象类
/**
 * 图的顶点类
 * @author King
 */
public class Vertex1 {
    String verName;
    Vertex1 nextNode;
}
1
2
3
4
5
6
7
8

3、图的实现类
import java.util.Scanner;

public class CreateGraph3 {

    /**
     * 根据用户输入的string类型的顶点返回该顶点
     * @param graph 图
     * @param str 输入数据
     * @return返回一个顶点
     */
    public Vertex1 getVertex(Graph1 graph,String str){
        for(int i=0;i<graph.verNum;i++){
            if(graph.vertexArray[i].verName.equals(str)){
                return graph.vertexArray[i];
            }
        }
        return null;
    }

    /**
     * 根据用户输入的数据初始化一个图，以邻接表的形式构建!
     * @param graph 生成的图
     */
    public void initialGraph(Graph1 graph){
        @SuppressWarnings("resource")
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入顶点数和边数：");
        graph.verNum=scan.nextInt();
        graph.edgeNum=scan.nextInt();

        System.out.println("请依次输入定点名称：");
        for(int i=0;i<graph.verNum;i++){
            Vertex1 vertex=new Vertex1();
            String name=scan.next();
            vertex.verName=name;
            vertex.nextNode=null;
            graph.vertexArray[i]=vertex;
        }

        System.out.println("请依次输入图的便边：");
        for(int i=0;i<graph.edgeNum;i++){
            String preV=scan.next();
            String folV=scan.next();

            Vertex1 v1=getVertex(graph,preV);
            if(v1==null)
                System.out.println("输入边存在图中没有的顶点！");

//下面代码是图构建的核心：链表操作
            Vertex1 v2=new Vertex1();
            v2.verName=folV;
            v2.nextNode=v1.nextNode;
            v1.nextNode=v2;

//紧接着下面注释的代码加上便是构建无向图的，不加则是构建有向图的！
//          Vertex1 reV2=getVertex(graph,folV);
//          if(reV2==null)
//              System.out.println("输入边存在图中没有的顶点！");
//          Vertex1 reV1=new Vertex1();
//          reV1.verName=preV;
//          reV1.nextNode=reV2.nextNode;
//          reV2.nextNode=reV1;
        }
    }

    /**
     * 输入图的邻接表
     * @param graph 待输出的图
     */
    public void outputGraph(Graph1 graph){
        System.out.println("输出图的邻接链表为：");
        for(int i=0;i<graph.verNum;i++){
            Vertex1 vertex=graph.vertexArray[i];
            System.out.print(vertex.verName);

            Vertex1 current=vertex.nextNode;
            while(current!=null){
                System.out.print("-->"+current.verName);
                current=current.nextNode;
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Graph1 graph=new Graph1();
        CreateGraph3 createGraph=new CreateGraph3();
        createGraph.initialGraph(graph);
        createGraph.outputGraph(graph);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

二、邻接链表使用边作为对象构建图

1、Graph对象类
import java.util.ArrayList;

public class Graph {

    ArrayList<Vertex> vertexList=new ArrayList<Vertex>();
    int vertexNum=0;
    int edgeNum=0;
    public Graph(){}
}
1
2
3
4
5
6
7
8
9

2、Edge对象类
/**
 * 图的边对象类
 * @author King
 */
public class Edge {
    int edgeName;
    Edge next;

    public Edge(){
    }
}
1
2
3
4
5
6
7
8
9
10
11

3、Vertex对象类<这里顶点对象只是辅助边构建图，不是作为邻接链表的对象>
/**
 * 图的点对象类
 * @author King
 */
public class Vertex {
    String vertexName;
    Edge firstEdge=new Edge();
    public Vertex(){
    }
}
1
2
3
4
5
6
7
8
9
10

4、图的实现类
import java.util.Scanner;
/**
 * 通过构建边和点的对象来创建图
 * @author King
 */
public class CreateGraph {

    /**
     * 根据顶点信息String，返回边的对象
     * @param graph 图
     * @param str 顶点名称
     * @return 返回的是边对象的标签
     */
    public int vtoe(Graph graph,String str){
        for(int i=0;i<graph.vertexNum;i++){
            if(graph.vertexList.get(i).vertexName.equals(str)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 该函数用于图的初始化的实现
     * @param graph 图
     */
    public void initialGraph(Graph graph){
        @SuppressWarnings("resource")
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入顶点数和边数：");
        graph.vertexNum=scan.nextInt();
        graph.edgeNum=scan.nextInt();

        System.out.println("请依次输入定点名称：");
        for(int i=0;i<graph.vertexNum;i++){
            Vertex vertex=new Vertex();
            String name=scan.next();
            vertex.vertexName=name;
            vertex.firstEdge=null;
            graph.vertexList.add(vertex);
        }

        System.out.println("请依次输入每个边：");
        for(int i=0;i<graph.edgeNum;i++){
            String preV=scan.next();
            String folV=scan.next();
            int v1=vtoe(graph,preV);
            int v2=vtoe(graph,folV);
            if(v1==-1 || v2==-1)
                System.out.println("输入顶点数据错误！");

//下面代码是图构建的核心：链表操作
            Edge edge1=new Edge();
            edge1.edgeName=v2;
            edge1.next=graph.vertexList.get(v1).firstEdge;
            graph.vertexList.get(v1).firstEdge=edge1;

//          下面代码加上便是构建无向图，不加便是构建有向图
//          Edge edge2=new Edge();
//          edge2.edgeName=v1;
//          edge2.next=graph.vertexList.get(v2).firstEdge;
//          graph.vertexList.get(v2).firstEdge=edge2;
        }
    }

    /**
     * 输出图的邻接链表表示
     * @param graph 图
     */
    public void outputGraph(Graph graph){
        Edge edge=new Edge();
        for(int i=0;i<graph.vertexNum;i++){
            System.out.print(graph.vertexList.get(i).vertexName);

            edge=graph.vertexList.get(i).firstEdge;
            while(edge!=null){
                System.out.print("-->"+graph.vertexList.get(edge.edgeName).vertexName);
                edge=edge.next;
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        CreateGraph createGraph=new CreateGraph();
        Graph graph=new Graph();
        createGraph.initialGraph(graph);
        createGraph.outputGraph(graph);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

5、以上面给出的图片中图为例运行结果展示： 





三、使用邻接表构建图的实例

问题：随机生成一个图（可以是有向图或是无向图），图的顶点大概100个左右，若是有向图则边大概2000条左右，若是无向图则边大概1000条左右！并计算出边的入度和出度

代码： 

1、Graph类
public class GraphRandom {

    VertexRandom[] vertexArray=new VertexRandom[200];
    int verNum=0;
    int edgeNum=0;
}
1
2
3
4
5
6

2、Vertexl类
public class VertexRandom {

    int verName;
    int inRadius,outRadius;
    VertexRandom nextNode;
}
1
2
3
4
5
6
7

3、随机图实现类
import java.util.Scanner;
/**
 * 随机生成一个图，计算每个顶点的入度和出度
 * @author King
 *
 */
public class CreateGraph2 {

    /**
     * 由顶点名称返回顶点集合中的该顶点
     * @param graph 图
     * @param name 顶点名称
     * @return返回顶点对象
     */
    public VertexRandom getVertex(GraphRandom graph,int name){
        for(int i=0;i<graph.verNum;i++){
            if(graph.vertexArray[i].verName==name){
                return graph.vertexArray[i];
            }
        }
        return null;
    }

    /**
     * 该顶点通过顶点和边构建图
     * @param graph 图
     */
    public void randomSpanning(GraphRandom graph){
        @SuppressWarnings("resource")
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入随机图的顶点个数：");
        graph.verNum=scan.nextInt();

        for(int i=1;i<=graph.verNum;i++){
            VertexRandom vertex=new VertexRandom();
            vertex.verName=i;
            vertex.nextNode=null;
            graph.vertexArray[i-1]=vertex;
        }

        int number=(int)(Math.random()*200+1000);
        System.out.println("随机生成的边的数量为："+number);
        graph.edgeNum=number;

        for(int i=0;i<graph.edgeNum;i++){
            int preV=(int)(Math.random()*100+1);
            int folV=(int)(Math.random()*100+1);
            while(folV==preV){
                folV=(int)(Math.random()*100+1);
            }

            VertexRandom vertex1=getVertex(graph,preV);
            if(vertex1==null)
                System.out.println("随机图中没有该顶点！");
            VertexRandom vertex2=new VertexRandom();
            vertex2.verName=folV;
            vertex2.nextNode=vertex1.nextNode;
            vertex1.nextNode=vertex2;

//          下面用于计算顶点的出度和入度的
            vertex1.outRadius++;
            VertexRandom v2=getVertex(graph,folV);
            if(v2==null)
                System.out.println("随机图中没有该顶点！");
            v2.inRadius++;

//          加上下面代码用于产生无向图
//          VertexRandom reVertex2=getVertex(graph,folV);
//          if(reVertex2==null)
//              System.out.println("随机图中没有该顶点！");
//          VertexRandom reVertex1=new VertexRandom();
//          reVertex1.verName=preV;
//          reVertex1.nextNode=reVertex2.nextNode;
//          reVertex2.nextNode=reVertex1;
        }
    }

    /**
     * 输出图的邻接链表
     * @param graph 图
     */
    public void outputGraph(GraphRandom graph){
        System.out.println("输出图的邻接链表为：");
        for(int i=0;i<graph.verNum;i++){
            VertexRandom vertex=graph.vertexArray[i];
            System.out.print(vertex.verName);

            VertexRandom current=vertex.nextNode;
            while(current!=null){
                System.out.print("-->"+current.verName);
                current=current.nextNode;
            }
            System.out.println();
        }
    }

    /**
     * 输出图的入度和出度
     * @param graph 图
     */
    public void IORadius(GraphRandom graph){
        for(int i=0;i<graph.verNum;i++){
            System.out.print("顶点"+(i+1)+"的出度为："+graph.vertexArray[i].outRadius);
            System.out.println(",入度为："+graph.vertexArray[i].inRadius);
        }
    }

    public static void main(String[] args) {
        GraphRandom graph=new GraphRandom();
        CreateGraph2 createGraph2=new CreateGraph2();
        createGraph2.randomSpanning(graph);
        createGraph2.outputGraph(graph);
        createGraph2.IORadius(graph);
    }
}

前言
本篇来谈一谈图的邻接表实现的两种方式，首先我们明确一点“学会图的邻接表实现的关键点在于“：你所建立的图的邻接表的对象是什么！
首先我们看一下《算法导论》中关于图的邻接表的定义：
图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成，其中每个列表对应于V中的一个顶点，对于每一个u∈V，邻接表Adj[u]包含所有满足条件(u，v)∈E的顶点v，亦即，Adj[u]包含图G中所有和顶点u相邻的顶点。(或者他也可能指向这些顶点的指针)，每个邻接表中的顶点一般以任意的顺序存储。
图的邻接表表示如下图所示：
定义总是比较晦涩难懂的，下面我们从如何实现图的邻接表表示来谈一谈！
1、邻接表构建图是必须需要一个Graph对象，也就是图对象！该对象包含属性有：顶点数、边数以及图的顶点集合；
2、正如上面所说，邻接链表的对象首先我们需要确定邻接表的对象，可以用顶点作为邻接链表的对象，自然也可以用边作为邻接链表的对象！下面将分别对这两种方式进行讲解！
一、邻接链表使用顶点作为对象构建图
1、Graph对象类
/**
* 自定义图类
* @author King
*/
public class Graph1 {
Vertex1[] vertexArray=new Vertex1[100];
int verNum=0;
int edgeNum=0;
}
2、Vertex对象类
/**
* 图的顶点类
* @author King
*/
public class Vertex1 {
String verName;
Vertex1 nextNode;
}
3、图的实现类
import java.util.Scanner;
public class CreateGraph3 {
/**
* 根据用户输入的string类型的顶点返回该顶点
* @param graph 图
* @param str 输入数据
* @return返回一个顶点
*/
public Vertex1 getVertex(Graph1 graph,String str){
for(int i=0;i
if(graph.vertexArray[i].verName.equals(str)){
return graph.vertexArray[i];
}
}
return null;
}
/**
* 根据用户输入的数据初始化一个图，以邻接表的形式构建!
* @param graph 生成的图
*/
public void initialGraph(Graph1 graph){
@SuppressWarnings("resource")
Scanner scan=new Scanner(System.in);
System.out.println("请输入顶点数和边数：");
graph.verNum=scan.nextInt();
graph.edgeNum=scan.nextInt();
System.out.println("请依次输入定点名称：");
for(int i=0;i
Vertex1 vertex=new Vertex1();
String name=scan.next();
vertex.verName=name;
vertex.nextNode=null;
graph.vertexArray[i]=vertex;
}
System.out.println("请依次输入图的便边：");
for(int i=0;i
String preV=scan.next();
String folV=scan.next();
Vertex1 v1=getVertex(graph,preV);
if(v1==null)
System.out.println("输入边存在图中没有的顶点！");
//下面代码是图构建的核心：链表操作
Vertex1 v2=new Vertex1();
v2.verName=folV;
v2.nextNode=v1.nextNode;
v1.nextNode=v2;
//紧接着下面注释的代码加上便是构建无向图的，不加则是构建有向图的！
// Vertex1 reV2=getVertex(graph,folV);
// if(reV2==null)
// System.out.println("输入边存在图中没有的顶点！");
// Vertex1 reV1=new Vertex1();
// reV1.verName=preV;
// reV1.nextNode=reV2.nextNode;
// reV2.nextNode=reV1;
}
}
/**
* 输入图的邻接表
* @param graph 待输出的图
*/
public void outputGraph(Graph1 graph){
System.out.println("输出图的邻接链表为：");
for(int i=0;i
Vertex1 vertex=graph.vertexArray[i];
System.out.print(vertex.verName);
Vertex1 current=vertex.nextNode;
while(current!=null){
System.out.print("-->"+current.verName);
current=current.nextNode;
}
System.out.println();
}
}
public static void main(String[] args) {
Graph1 graph=new Graph1();
CreateGraph3 createGraph=new CreateGraph3();
createGraph.initialGraph(graph);
createGraph.outputGraph(graph);
}
}
二、邻接链表使用边作为对象构建图
1、Graph对象类
import java.util.ArrayList;
public class Graph {
ArrayList vertexList=new ArrayList();
int vertexNum=0;
int edgeNum=0;
public Graph(){}
}
2、Edge对象类
/**
* 图的边对象类
* @author King
*/
public class Edge {
int edgeName;
Edge next;
public Edge(){
}
}
3、Vertex对象类
/**
* 图的点对象类
* @author King
*/
public class Vertex {
String vertexName;
Edge firstEdge=new Edge();
public Vertex(){
}
}
4、图的实现类
import java.util.Scanner;
/**
* 通过构建边和点的对象来创建图
* @author King
*/
public class CreateGraph {
/**
* 根据顶点信息String，返回边的对象
* @param graph 图
* @param str 顶点名称
* @return 返回的是边对象的标签
*/
public int vtoe(Graph graph,String str){
for(int i=0;i
if(graph.vertexList.get(i).vertexName.equals(str)){
return i;
}
}
return -1;
}
/**
* 该函数用于图的初始化的实现
* @param graph 图
*/
public void initialGraph(Graph graph){
@SuppressWarnings("resource")
Scanner scan=new Scanner(System.in);
System.out.println("请输入顶点数和边数：");
graph.vertexNum=scan.nextInt();
graph.edgeNum=scan.nextInt();
System.out.println("请依次输入定点名称：");
for(int i=0;i
Vertex vertex=new Vertex();
String name=scan.next();
vertex.vertexName=name;
vertex.firstEdge=null;
graph.vertexList.add(vertex);
}
System.out.println("请依次输入每个边：");
for(int i=0;i
String preV=scan.next();
String folV=scan.next();
int v1=vtoe(graph,preV);
int v2=vtoe(graph,folV);
if(v1==-1 || v2==-1)
System.out.println("输入顶点数据错误！");
//下面代码是图构建的核心：链表操作
Edge edge1=new Edge();
edge1.edgeName=v2;
edge1.next=graph.vertexList.get(v1).firstEdge;
graph.vertexList.get(v1).firstEdge=edge1;
// 下面代码加上便是构建无向图，不加便是构建有向图
// Edge edge2=new Edge();
// edge2.edgeName=v1;
// edge2.next=graph.vertexList.get(v2).firstEdge;
// graph.vertexList.get(v2).firstEdge=edge2;
}
}
/**
* 输出图的邻接链表表示
* @param graph 图
*/
public void outputGraph(Graph graph){
Edge edge=new Edge();
for(int i=0;i
System.out.print(graph.vertexList.get(i).vertexName);
edge=graph.vertexList.get(i).firstEdge;
while(edge!=null){
System.out.print("-->"+graph.vertexList.get(edge.edgeName).vertexName);
edge=edge.next;
}
System.out.println();
}
}
public static void main(String[] args) {
CreateGraph createGraph=new CreateGraph();
Graph graph=new Graph();
createGraph.initialGraph(graph);
createGraph.outputGraph(graph);
}
}
5、以上面给出的图片中图为例运行结果展示：
三、使用邻接表构建图的实例
问题：随机生成一个图(可以是有向图或是无向图)，图的顶点大概100个左右，若是有向图则边大概2000条左右，若是无向图则边大概1000条左右！并计算出边的入度和出度
代码：
1、Graph类
public class GraphRandom {
VertexRandom[] vertexArray=new VertexRandom[200];
int verNum=0;
int edgeNum=0;
}
2、Vertexl类
public class VertexRandom {
int verName;
int inRadius,outRadius;
VertexRandom nextNode;
}
3、随机图实现类
import java.util.Scanner;
/**
* 随机生成一个图，计算每个顶点的入度和出度
* @author King
*
*/
public class CreateGraph2 {
/**
* 由顶点名称返回顶点集合中的该顶点
* @param graph 图
* @param name 顶点名称
* @return返回顶点对象
*/
public VertexRandom getVertex(GraphRandom graph,int name){
for(int i=0;i
if(graph.vertexArray[i].verName==name){
return graph.vertexArray[i];
}
}
return null;
}
/**
* 该顶点通过顶点和边构建图
* @param graph 图
*/
public void randomSpanning(GraphRandom graph){
@SuppressWarnings("resource")
Scanner scan=new Scanner(System.in);
System.out.println("请输入随机图的顶点个数：");
graph.verNum=scan.nextInt();
for(int i=1;i<=graph.verNum;i++){
VertexRandom vertex=new VertexRandom();
vertex.verName=i;
vertex.nextNode=null;
graph.vertexArray[i-1]=vertex;
}
int number=(int)(Math.random()*200+1000);
System.out.println("随机生成的边的数量为："+number);
graph.edgeNum=number;
for(int i=0;i
int preV=(int)(Math.random()*100+1);
int folV=(int)(Math.random()*100+1);
while(folV==preV){
folV=(int)(Math.random()*100+1);
}
VertexRandom vertex1=getVertex(graph,preV);
if(vertex1==null)
System.out.println("随机图中没有该顶点！");
VertexRandom vertex2=new VertexRandom();
vertex2.verName=folV;
vertex2.nextNode=vertex1.nextNode;
vertex1.nextNode=vertex2;
// 下面用于计算顶点的出度和入度的
vertex1.outRadius++;
VertexRandom v2=getVertex(graph,folV);
if(v2==null)
System.out.println("随机图中没有该顶点！");
v2.inRadius++;
// 加上下面代码用于产生无向图
// VertexRandom reVertex2=getVertex(graph,folV);
// if(reVertex2==null)
// System.out.println("随机图中没有该顶点！");
// VertexRandom reVertex1=new VertexRandom();
// reVertex1.verName=preV;
// reVertex1.nextNode=reVertex2.nextNode;
// reVertex2.nextNode=reVertex1;
}
}
/**
* 输出图的邻接链表
* @param graph 图
*/
public void outputGraph(GraphRandom graph){
System.out.println("输出图的邻接链表为：");
for(int i=0;i
VertexRandom vertex=graph.vertexArray[i];
System.out.print(vertex.verName);
VertexRandom current=vertex.nextNode;
while(current!=null){
System.out.print("-->"+current.verName);
current=current.nextNode;
}
System.out.println();
}
}
/**
* 输出图的入度和出度
* @param graph 图
*/
public void IORadius(GraphRandom graph){
for(int i=0;i
System.out.print("顶点"+(i+1)+"的出度为："+graph.vertexArray[i].outRadius);
System.out.println(",入度为："+graph.vertexArray[i].inRadius);
}
}
public static void main(String[] args) {
GraphRandom graph=new GraphRandom();
CreateGraph2 createGraph2=new CreateGraph2();
createGraph2.randomSpanning(graph);
createGraph2.outputGraph(graph);
createGraph2.IORadius(graph);
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

前言
本篇来谈一谈图的邻接表实现的两种方式，首先我们明确一点“学会图的邻接表实现的关键点在于“：你所建立的图的邻接表的对象是什么！
首先我们看一下《算法导论》中关于图的邻接表的定义：
图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成，其中每个列表对应于V中的一个顶点，对于每一个u∈V，邻接表Adj[u]包含所有满足条件(u，v)∈E的顶点v，亦即，Adj[u]包含图G中所有和顶点u相邻的顶点。(或者他也可能指向这些顶点的指针)，每个邻接表中的顶点一般以任意的顺序存储。
图的邻接表表示如下图所示：
定义总是比较晦涩难懂的，下面我们从如何实现图的邻接表表示来谈一谈！
1、邻接表构建图是必须需要一个Graph对象，也就是图对象！该对象包含属性有：顶点数、边数以及图的顶点集合；
2、正如上面所说，邻接链表的对象首先我们需要确定邻接表的对象，可以用顶点作为邻接链表的对象，自然也可以用边作为邻接链表的对象！下面将分别对这两种方式进行讲解！
一、邻接链表使用顶点作为对象构建图
1、Graph对象类
/**
* 自定义图类
* @author King
*/
public class Graph1 {
Vertex1[] vertexArray=new Vertex1[100];
int verNum=0;
int edgeNum=0;
}
2、Vertex对象类
/**
* 图的顶点类
* @author King
*/
public class Vertex1 {
String verName;
Vertex1 nextNode;
}
3、图的实现类
import java.util.Scanner;
public class CreateGraph3 {
/**
* 根据用户输入的string类型的顶点返回该顶点
* @param graph 图
* @param str 输入数据
* @return返回一个顶点
*/
public Vertex1 getVertex(Graph1 graph,String str){
for(int i=0;i
if(graph.vertexArray[i].verName.equals(str)){
return graph.vertexArray[i];
}
}
return null;
}
/**
* 根据用户输入的数据初始化一个图，以邻接表的形式构建!
* @param graph 生成的图
*/
public void initialGraph(Graph1 graph){
@SuppressWarnings("resource")
Scanner scan=new Scanner(System.in);
System.out.println("请输入顶点数和边数：");
graph.verNum=scan.nextInt();
graph.edgeNum=scan.nextInt();
System.out.println("请依次输入定点名称：");
for(int i=0;i
Vertex1 vertex=new Vertex1();
String name=scan.next();
vertex.verName=name;
vertex.nextNode=null;
graph.vertexArray[i]=vertex;
}
System.out.println("请依次输入图的便边：");
for(int i=0;i
String preV=scan.next();
String folV=scan.next();
Vertex1 v1=getVertex(graph,preV);
if(v1==null)
System.out.println("输入边存在图中没有的顶点！");
//下面代码是图构建的核心：链表操作
Vertex1 v2=new Vertex1();
v2.verName=folV;
v2.nextNode=v1.nextNode;
v1.nextNode=v2;
//紧接着下面注释的代码加上便是构建无向图的，不加则是构建有向图的！
// Vertex1 reV2=getVertex(graph,folV);
// if(reV2==null)
// System.out.println("输入边存在图中没有的顶点！");
// Vertex1 reV1=new Vertex1();
// reV1.verName=preV;
// reV1.nextNode=reV2.nextNode;
// reV2.nextNode=reV1;
}
}
/**
* 输入图的邻接表
* @param graph 待输出的图
*/
public void outputGraph(Graph1 graph){
System.out.println("输出图的邻接链表为：");
for(int i=0;i
Vertex1 vertex=graph.vertexArray[i];
System.out.print(vertex.verName);
Vertex1 current=vertex.nextNode;
while(current!=null){
System.out.print("-->"+current.verName);
current=current.nextNode;
}
System.out.println();
}
}
public static void main(String[] args) {
Graph1 graph=new Graph1();
CreateGraph3 createGraph=new CreateGraph3();
createGraph.initialGraph(graph);
createGraph.outputGraph(graph);
}
}
二、邻接链表使用边作为对象构建图
1、Graph对象类
import java.util.ArrayList;
public class Graph {
ArrayList vertexList=new ArrayList();
int vertexNum=0;
int edgeNum=0;
public Graph(){}
}
2、Edge对象类
/**
* 图的边对象类
* @author King
*/
public class Edge {
int edgeName;
Edge next;
public Edge(){
}
}
3、Vertex对象类
/**
* 图的点对象类
* @author King
*/
public class Vertex {
String vertexName;
Edge firstEdge=new Edge();
public Vertex(){
}
}
4、图的实现类
import java.util.Scanner;
/**
* 通过构建边和点的对象来创建图
* @author King
*/
public class CreateGraph {
/**
* 根据顶点信息String，返回边的对象
* @param graph 图
* @param str 顶点名称
* @return 返回的是边对象的标签
*/
public int vtoe(Graph graph,String str){
for(int i=0;i
if(graph.vertexList.get(i).vertexName.equals(str)){
return i;
}
}
return -1;
}
/**
* 该函数用于图的初始化的实现
* @param graph 图
*/
public void initialGraph(Graph graph){
@SuppressWarnings("resource")
Scanner scan=new Scanner(System.in);
System.out.println("请输入顶点数和边数：");
graph.vertexNum=scan.nextInt();
graph.edgeNum=scan.nextInt();
System.out.println("请依次输入定点名称：");
for(int i=0;i
Vertex vertex=new Vertex();
String name=scan.next();
vertex.vertexName=name;
vertex.firstEdge=null;
graph.vertexList.add(vertex);
}
System.out.println("请依次输入每个边：");
for(int i=0;i
String preV=scan.next();
String folV=scan.next();
int v1=vtoe(graph,preV);
int v2=vtoe(graph,folV);
if(v1==-1 || v2==-1)
System.out.println("输入顶点数据错误！");
//下面代码是图构建的核心：链表操作
Edge edge1=new Edge();
edge1.edgeName=v2;
edge1.next=graph.vertexList.get(v1).firstEdge;
graph.vertexList.get(v1).firstEdge=edge1;
// 下面代码加上便是构建无向图，不加便是构建有向图
// Edge edge2=new Edge();
// edge2.edgeName=v1;
// edge2.next=graph.vertexList.get(v2).firstEdge;
// graph.vertexList.get(v2).firstEdge=edge2;
}
}
/**
* 输出图的邻接链表表示
* @param graph 图
*/
public void outputGraph(Graph graph){
Edge edge=new Edge();
for(int i=0;i
System.out.print(graph.vertexList.get(i).vertexName);
edge=graph.vertexList.get(i).firstEdge;
while(edge!=null){
System.out.print("-->"+graph.vertexList.get(edge.edgeName).vertexName);
edge=edge.next;
}
System.out.println();
}
}
public static void main(String[] args) {
CreateGraph createGraph=new CreateGraph();
Graph graph=new Graph();
createGraph.initialGraph(graph);
createGraph.outputGraph(graph);
}
}
5、以上面给出的图片中图为例运行结果展示：
三、使用邻接表构建图的实例
问题：随机生成一个图(可以是有向图或是无向图)，图的顶点大概100个左右，若是有向图则边大概2000条左右，若是无向图则边大概1000条左右！并计算出边的入度和出度
代码：
1、Graph类
public class GraphRandom {
VertexRandom[] vertexArray=new VertexRandom[200];
int verNum=0;
int edgeNum=0;
}
2、Vertexl类
public class VertexRandom {
int verName;
int inRadius,outRadius;
VertexRandom nextNode;
}
3、随机图实现类
import java.util.Scanner;
/**
* 随机生成一个图，计算每个顶点的入度和出度
* @author King
*
*/
public class CreateGraph2 {
/**
* 由顶点名称返回顶点集合中的该顶点
* @param graph 图
* @param name 顶点名称
* @return返回顶点对象
*/
public VertexRandom getVertex(GraphRandom graph,int name){
for(int i=0;i
if(graph.vertexArray[i].verName==name){
return graph.vertexArray[i];
}
}
return null;
}
/**
* 该顶点通过顶点和边构建图
* @param graph 图
*/
public void randomSpanning(GraphRandom graph){
@SuppressWarnings("resource")
Scanner scan=new Scanner(System.in);
System.out.println("请输入随机图的顶点个数：");
graph.verNum=scan.nextInt();
for(int i=1;i<=graph.verNum;i++){
VertexRandom vertex=new VertexRandom();
vertex.verName=i;
vertex.nextNode=null;
graph.vertexArray[i-1]=vertex;
}
int number=(int)(Math.random()*200+1000);
System.out.println("随机生成的边的数量为："+number);
graph.edgeNum=number;
for(int i=0;i
int preV=(int)(Math.random()*100+1);
int folV=(int)(Math.random()*100+1);
while(folV==preV){
folV=(int)(Math.random()*100+1);
}
VertexRandom vertex1=getVertex(graph,preV);
if(vertex1==null)
System.out.println("随机图中没有该顶点！");
VertexRandom vertex2=new VertexRandom();
vertex2.verName=folV;
vertex2.nextNode=vertex1.nextNode;
vertex1.nextNode=vertex2;
// 下面用于计算顶点的出度和入度的
vertex1.outRadius++;
VertexRandom v2=getVertex(graph,folV);
if(v2==null)
System.out.println("随机图中没有该顶点！");
v2.inRadius++;
// 加上下面代码用于产生无向图
// VertexRandom reVertex2=getVertex(graph,folV);
// if(reVertex2==null)
// System.out.println("随机图中没有该顶点！");
// VertexRandom reVertex1=new VertexRandom();
// reVertex1.verName=preV;
// reVertex1.nextNode=reVertex2.nextNode;
// reVertex2.nextNode=reVertex1;
}
}
/**
* 输出图的邻接链表
* @param graph 图
*/
public void outputGraph(GraphRandom graph){
System.out.println("输出图的邻接链表为：");
for(int i=0;i
VertexRandom vertex=graph.vertexArray[i];
System.out.print(vertex.verName);
VertexRandom current=vertex.nextNode;
while(current!=null){
System.out.print("-->"+current.verName);
current=current.nextNode;
}
System.out.println();
}
}
/**
* 输出图的入度和出度
* @param graph 图
*/
public void IORadius(GraphRandom graph){
for(int i=0;i
System.out.print("顶点"+(i+1)+"的出度为："+graph.vertexArray[i].outRadius);
System.out.println(",入度为："+graph.vertexArray[i].inRadius);
}
}
public static void main(String[] args) {
GraphRandom graph=new GraphRandom();
CreateGraph2 createGraph2=new CreateGraph2();
createGraph2.randomSpanning(graph);
createGraph2.outputGraph(graph);
createGraph2.IORadius(graph);
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持谷谷点程序。