数据结构与算法-图（JAVA语言描述）

最新推荐文章于 2023-03-19 13:29:09 发布
最新推荐文章于 2023-03-19 13:29:09 发布
阅读量518 收藏 3
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013767488/article/details/89522328
版权

图的表示

对下图所示的无向图，可使用一个7X7的邻接矩阵表示：

final int mw = Integer.MAX_VALUE;
int[][] C = new int[][]{
                {0, 5, 2, mw, mw, mw, mw},
                {5, 0, mw, 1, 6, mw, mw},
                {2, mw, 0, 6, mw, 8, mw},
                {mw, 1, 6, 0, 1, 2, mw},
                {mw, 6, mw, 1, 0, mw, 7},
                {mw, mw, 8, 2, mw, 0, 3},
                {mw, mw, mw, mw, 7, 3, 0}
        };

在这里插入图片描述

图的遍历（BFS & DFS）


/**
 * 图
 */
public class Graph<T> {
    public static void main(String[] args) {
        final int mw = Integer.MAX_VALUE;
        int[][] graph = new int[][]{
                {0, 5, 2, mw, mw, mw, mw},
                {5, 0, mw, 1, 6, mw, mw},
                {2, mw, 0, 6, mw, 8, mw},
                {mw, 1, 6, 0, 1, 2, mw},
                {mw, 6, mw, 1, 0, mw, 7},
                {mw, mw, 8, 2, mw, 0, 3},
                {mw, mw, mw, mw, 7, 3, 0}
        };
        char[] vertexes = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        Graph<Character> theGraph = new Graph<>(vertexes, graph);
        //theGraph.dfs(0);
        //theGraph.bfs(1);
      
    }
    
    private static final int MAX_VERTS = 20;
    private Vertex[] vertexList;// 顶点数组
    private int adjMat[][];     // 邻接矩阵
    private int nVerts;         // 当前顶点总数
    private StackX theStack;
    private QueueX theQueueX;
    
    public Graph() {// 构造图
        vertexList = new Vertex[MAX_VERTS];

        adjMat = new int[MAX_VERTS][MAX_VERTS];
        nVerts = 0;
        for (int i = 0; i < MAX_VERTS; i++) {
            for (int j = 0; j < MAX_VERTS; j++) {
                adjMat[i][j] = 0;
            }
        }
        theStack = new StackX();
        theQueueX = new QueueX();
    }

    public Graph(char[] vertexList, int[][] adjMat) {
        if (vertexList.length != adjMat.length) {
            throw new RuntimeException("illegal argument");
        }

        this.adjMat = adjMat;
        this.nVerts = vertexList.length;
        theStack = new StackX();
        theQueueX = new QueueX();

        this.vertexList = new Vertex[nVerts];
        for (int i = 0; i < vertexList.length; i++) {
            this.vertexList[i] = new Vertex<>(vertexList[i]);
        }
    }

    public void addVertex(T lab) {// 添加顶点
        vertexList[nVerts++] = new Vertex<>(lab);
    }

    public void addEdge(int start, int end, int weight) {// 添加边
        adjMat[start][end] = weight;
    }

    public void displayVertex(int v) {// 打印数组中v位置下的顶点名
        System.out.print(vertexList[v].lable + "\t");
    }

    public int getAdjUnvisitedVertex(int v) {// 获取和v邻接的未访问的顶点
        for (int i = 0; i < nVerts; i++) {
            if (adjMat[v][i] > 0 && adjMat[v][i] < Integer.MAX_VALUE && !vertexList[i].wasVisited) {
                return i;
            }
        }
        return -1;
    }

    public void dfs(int start) {// 深度优先搜索
        vertexList[start].wasVisited = true;
        displayVertex(start);
        theStack.push(start);

        while (!theStack.isEmpty()) {
            int v = getAdjUnvisitedVertex(theStack.peek());
            if (v == -1) {
                theStack.pop();
            } else {
                vertexList[v].wasVisited = true;
                displayVertex(v);
                theStack.push(v);
            }
        }

        for (int i = 0; i < nVerts; i++) {
            vertexList[i].wasVisited = false;// 重置，防止后边再次使用dfs
        }
    }

    public void bfs(int start) {// 广度优先搜索
        vertexList[start].wasVisited = true;
        displayVertex(start);
        theQueueX.insert(start);
        int v2;

        while (!theQueueX.isEmpty()) {
            int v1 = theQueueX.remove();

            while ((v2 = getAdjUnvisitedVertex(v1)) != -1) {
                vertexList[v2].wasVisited = true;
                displayVertex(v2);
                theQueueX.insert(v2);
            }
        }

        for (int j = 0; j < nVerts; j++) {
            vertexList[j].wasVisited = false;
        }
    }

}

class StackX {// 自定义栈
    private static final int SIZE = 20;
    private int[] st;
    private int top;

    public StackX() {
        st = new int[SIZE];
        top = -1;
    }

    public void push(int j) {
        st[++top] = j;
    }

    public int pop() {
        if (top == 0) {
            return -1;
        }
        return st[--top];
    }

    public int peek() {
        return st[top];
    }

    public boolean isEmpty() {
        return (top == -1);
    }
}

class QueueX {
    private final int SIZE = 20;
    private int[] queArray;
    private int front;
    private int rear;

    public QueueX() {
        queArray = new int[SIZE];
        front = 0;
        rear = -1;
    }

    public void insert(int j) {// 入队
        if (rear == SIZE - 1) {
            rear = -1;
        }
        queArray[++rear] = j;
    }

    public int remove() {// 出队
        if (!isEmpty()) {
            return queArray[front++];
        } else {
            return -1;
        }
    }


    public boolean isEmpty() {
        return (rear + 1 == front);
    }
}

/**
 * 图的节点
 */
class Vertex<T> {
    /**
     * 节点名称
     */
    public T lable;
    /**
     * 是否已经被遍历
     */
    public boolean wasVisited;

    public Vertex(T lab) {
        lable = lab;
        wasVisited = false;
    }
}

最短路径

dijkstra

在这里插入图片描述

在这里插入图片描述


    public void dijkstra() { //最短路径
        int[] dis = new int[nVerts];    //距离表
        int[] prevs = new int[nVerts];  //前置节点

        vertexList[0].wasVisited = true;
        System.arraycopy(adjMat[0], 0, dis, 0, nVerts);

        while (true) {
            int min = Integer.MAX_VALUE;
            int index = -1;
            //找出最近顶点
            for (int i = 0; i < nVerts; i++) {

                if (!vertexList[i].wasVisited) {
                    if (dis[i] < min) {
                        index = i;
                        min = dis[i];
                    }
                }
            }

            //结束条件
            if (index == -1) break;

            //更新距离表
            vertexList[index].wasVisited = true;
            for (int i = 0; i < nVerts; i++) {
                if (adjMat[index][i] != Integer.MAX_VALUE) {
                    if (dis[i] > (min + adjMat[index][i])) {
                        dis[i] = min + adjMat[index][i];
                        prevs[i] = index;
                    }
                }
            }
        }
        //输出结果
        System.out.println(dis[nVerts - 1]);
        printPrevs(prevs, nVerts - 1);
    }

    private void printPrevs(int[] prev, int i) {
        if (i > 0) {
            printPrevs(prev, prev[i]);
        }
        System.out.print(vertexList[i].lable.toString() + "\t");

    }

Floyd

在这里插入图片描述
暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费以及方便计划旅程，小哼希望在出发之前知道任意两个城市之前的最短路程。

在这里插入图片描述 在这里插入图片描述
上图中有4个城市8条公路，公路上的数字表示这条公路的长短。请注意这些公路是单向的。我们现在需要求任意两个城市之间的最短路程，也就是求任意两个点之间的最短路径。这个问题这也被称为多源最短路径问题。
现在回到问题：如何求任意两点之间最短路径呢？通过之前的学习我们知道通过深度或广度优先搜索可以求出两点之间的最短路径。所以进行n2遍深度或广度优先搜索，即对每两个点都进行一次深度或广度优先搜索，便可以求得任意两点之间的最短路径。可是还有没有别的方法呢？

我们来想一想，根据我们以往的经验，如果要让任意两点（例如从顶点a点到顶点b）之间的路程变短，只能引入第三个点（顶点k），并通过这个顶点k中转即a->k->b，才可能缩短原来从顶点a点到顶点b的路程。那么这个中转的顶点k是1~n中的哪个点呢？甚至有时候不只通过一个点，而是经过两个点或者更多点中转会更短，即a->k1->k2b->或者a->k1->k2…->k->i…->b。比如上图中从4号城市到3号城市（4->3）的路程e[4][3]原本是12。如果只通过1号城市中转（4->1->3），路程将缩短为11（e[4][1]+e[1][3]=5+6=11）。其实1号城市到3号城市也可以通过2号城市中转，使得1号到3号城市的路程缩短为5（e[1][2]+e[2][3]=2+3=5）。所以如果同时经过1号和2号两个城市中转的话，从4号城市到3号城市的路程会进一步缩短为10。通过这个的例子，我们发现每个顶点都有可能使得另外两个顶点之间的路程变短。


    public int[][] floyd() {
        int[][] C = new int[nVerts][nVerts];
        for (int i = 0; i < nVerts; i++) {
            System.arraycopy(adjMat[i], 0, C[i], 0, nVerts);
        }
        
        for (int k = 0; k < nVerts; k++) {
            for (int i = 0; i < nVerts; i++) {
                for (int j = 0; j < nVerts; j++) {
                    if (C[i][k] != Integer.MAX_VALUE && C[k][j] != Integer.MAX_VALUE 
                    &&  C[i][k] + C[k][j] < C[i][j]) {
                        C[i][j] = C[i][k] + C[k][j];
                    }

                }
            }
        }
        
        for (int i = 0; i < nVerts; i++) {
            for (int j = 0; j < nVerts; j++) {
                if (i == j) continue;
                if (C[i][j] == mw)
                    System.out.println(i + "到" + j + "之间没路径");
                else
                    System.out.println(i + "到" + j + "之间的最短路径长度为：" + C[i][j]);
            }
        }

        return C;
    }
@Levin
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法--Java语言描述
01-06
在这个“数据结构与算法--Java语言描述”的资料中，我们有望深入理解这些核心概念，并通过Java语言来实现它们，从而提升编程技能。 数据结构是组织和存储数据的方式，它决定了数据的访问效率和操作复杂性。常见的...
Graph
MP-214的博客
04-20 203
图结构 一般是数组存储节点 关系另外存储：邻接矩阵，邻接表 vertex public class Vertex { private String value; public boolean visited; public void setValue(String value) { this.value = value; } public String getValue() { ...
acm-最短路径算法
weixin_43460331的博客
05-22 465
最短路径算法 一、求出最短路径的长度 以下没有特别说明的话，dis[u][v]表示从u到v最短路径长度，w[u][v]表示连接u，v的边的长度。1.Floyed-Warshall算法 O(N3) 　　 简称Floyed(弗洛伊德)算法，是最简单的最短路径算法，可以计算图中任意两点间的最短路径。Floyed的时间复杂度是O (N3)，适用于出现负边权的情况。 算法描述： 初始化：点u、v如...
ACM训练-floyd算法
03-14 119
问题描述：多源点问题和负权值图的最短路径 算法描述：Floyd算法是一个经典的动态规划算法。从任意节点i到任意节点j的最短路径不外乎2种可能，1是直接从i到j，2是从i经过若干个节点k到j。所以，我们假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路...
ACM模板——Floyd算法
Kiritow的学园
08-03 625
Floyd算法是用于求解所有点对之间的最短距离，如果只需要求一个起点到所有其他点的最短距离应该使用Dijstra算法。 Floyd核心Logic 注：m[f][t] 意为 从f出发到t点的距离. 输入可能是边的形式或者是图的形式，需要灵活处理。 for(int k=1;k<=n;k++) { for(int f=1;f<=n;f++)
ACM_Floyd-Warshall (Floyd) 算法
北
07-20 321
Floyd算法相当于Dijkstra算法的扩展版，由原来的一维数组到现在的二维数组，所以Floyd算法可以求得任何一个点到其他所有点的最短路径； for循环中k，i，j的顺序是不能改变的：k是中间点，每一个中间点都有可能能够更新任意两点之间的距离，所以，最外层for循环每轮到一个k值都得把整个二维数组跑一遍，能用k更新的就更新！ #include #include using namespac
数据结构与算法分析--java语言描述.pdf
09-14
数据结构与算法分析--java语言描述.pdf
数据结构与算法分析（Java语言描述）习题答案（第三版）.docx
06-24
在《数据结构与算法分析（Java语言描述）》（第三版）这本教材中，我们看到涉及了关于数据结构、算法以及程序设计的基础概念。在给出的文档中，部分题目和答案涵盖了递归、数学推理、文件处理以及计算理论等多个方面...
数据结构与算法分析_java语言描述_Mark_Allen_Weiss著_课后习题答案.pdf
07-14
数据结构与算法分析_java语言描述_Mark_Allen_Weiss著_课后习题答案.pdf
深度解析(一六)Floyd算法
weixin_34194087的博客
02-24 271
Floyd算法(一)之 C语言详解 本章介绍弗洛伊德算法。和以往一样，本文会先对弗洛伊德算法的理论论知识进行介绍，然后给出C语言的实现。后续再分别给出C++和Java版本的实现。 目录 1. 弗洛伊德算法介绍 2. 弗洛伊德算法图解 3. 弗洛伊德算法的代码说明 4. 弗洛伊德算法的源码 转载请注明出处：http://www.cnblogs.com/skywang12345/ 更多内...
Floyd（弗洛伊德）最小环核心模板题
最新发布
bloddy_mary的博客
03-19 240
我是一个小学六年级学生，今天我刚学了Floyd（弗洛伊德）算法，就想和大家分享了。希望大家能喜欢我的文章。希望本文能为你们提供学习资料！
数据结构(四)图(一)图的表示
书弋江山的博客
06-28 334
public class ImageGraph1 { private final int V;//顶点数 private int E ;//边数 private Bag<Integer>[] adj;//邻接表 public ImageGraph1(int v){ this.V = v; this.E = 0; thi
图论
qq_43701330的博客
07-22 637
图论 图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系 1.1图的重要组成部分 节点:Vertex 边:Edge 可以表示：交通运输、社交网络、互联网、工作安排、脑区活动、程序状态执行 1.2图的分类 无向图...
java graph 数据结构_数据结构图-JAVA实现
weixin_34052714的博客
02-19 462
package com.sunny.graph.matrix;public class Graph {private int vertexSize;//顶点数量private int [] vertexs;//顶点数组private int[][] matrix;//邻接矩阵private final static int MAX_WEIGHT = 1000;//权值即图的无穷大。这里只是做了最大...
guava的Graph示例
kanpiaoxue的专栏
08-11 1397
      public interface Node&lt;T&gt; { T get(); }   public interface Edge&lt;T&gt; { T get(); }       public class DataEntity implements Node&lt;DataEntity&gt; { private ...
算法（第四版）-图
qq_37439229的博客
06-29 256
图 一般只会写代码，以后用来给自己参考的demo (数据结构与算法c++描述也太难看懂了。。。说的是人话吗。。还是这个亲切) （前面几章demo写本地了，有时间再发吧。。） 无向图（邻接表实现。。又像拉链法。。。Bag） public class Graph Graph( int v ) 创建一个含有v个顶点但不含边的图 Graph( In in) 读入一个图 int V() 顶点 int E() 边数 void add
java与python两个小人动图_用了都说好的Python、Java双实现的Graph图数据结构的定义...
weixin_31066503的博客
01-27 127
'''一个好用的Graph的定义权重，from Node到to Node【weight,from ,to[12, 2, 4];[4, 2, 7]....】好的定义已经帮你解决了很多问题，比如这个图的Node出度入度直接就可以求python代码的图定义是我直接从下面的Java代码翻译过来的'''class Graph:def __init__(self):self.nodes...
Java实现图的存储和创建
闻风听雨的博客
07-26 1223
带权无向图 存储结构 存储结构选用邻接表。 当一个图为稀疏图时，使用邻接矩阵法显然要浪费大量的存储空间，而图的邻接表法结合了顺序存储和链式存储方法，大大减少了这种不必要的浪费。 当然，即使我们所处理的图不是稀疏图，邻接表法也是能够胜任的。 图、顶点以及边的代码定义 public class graph_t { //邻接表实现的带权无向图 private ArrayList<VNode> vertices; //邻接表 private int vexNum; //顶点
T和Class<T>以及Class<?>的理解
qq_37150783的博客
11-27 4498
T  bean ; Class bean; Class bean; 在利用反射获取属性时，遇到这样的写法，对此专门查些资料研究了一下。 单独的T 代表一个类型 而 Class和Class代表这个类型所对应的类 Class在实例化的时候，T要替换成具体类 Class它是个通配泛型，?可以代表任何类型    受限统配，表示T的一个未知子类。 下限统配，表示T
Java语言版数据结构与算法详解
"《数据结构与算法（JAVA语言版）》是一本介绍数据结构和算法的书籍，通过Java语言进行讲解。书中详细介绍了Java的基本知识，包括数据类型、流程控制、字符串、数组以及面向对象特性如类、继承、接口和异常处理。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值