邻接矩阵来实现带权图结构,并通过Dijkstra算法寻找最短路径

1.邻接矩阵来实现带权图结构

package com.upupgogogo;

/**
 * Created by upupgogogo on 2018/3/26.上午11:45
 */
public class AdjMatrixGraph<T> {

    protected SeqList<T> vertexlist;    //顺序表储存图的定点集合
    protected int[][] adjmatrix;        //图的邻接矩阵
    private final int MAX_WEIGHT = 99999;  //最大权值(表示无穷大)

    public AdjMatrixGraph(int size){
        size = size < 10 ? 10 : size;
        this.vertexlist = new SeqList<>(size);  //构造容量为size的空顺序表,当前定点数为0
        this.adjmatrix = new int[size][size];   //初始化邻接矩阵
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                this.adjmatrix[i][j] = (i == j) ? 0 : MAX_WEIGHT;
    }

    public AdjMatrixGraph(T[] vertexlist, Edge[] edges){
        this(vertexlist.length);
        if (vertexlist == null)
            return;
        for (int i = 0; i < vertexlist.length; i++)
            insertVertex(vertexlist[i]);
        if (edges != null)
            for (int j = 0; j < edges.length; j++)
                insertEdge(edges[j]);
    }

    //返回顶点数
    public int vertexCount(){return this.vertexlist.length();}

    //返回顶点vi的数据元素
    public T get(int i){ return this.vertexlist.get(i);}

    //返回<vi,vj>边的权值
    public int getWeight(int i, int j){

        return this.adjmatrix[i][j];
    }

    public void checkIndex(int i, int j){
        if (i > this.vertexCount() || i < 0 || j > this.vertexCount() || j < 0)
            throw new IndexOutOfBoundsException("size ="+this.vertexCount());
    }
    
    //新增一个顶点
    public int insertVertex(T x){
        //顺序表自动扩容
        this.vertexlist.add(x);
        
        //二维数组判断是否扩容
        if (this.vertexCount() > this.adjmatrix.length){
            int[][] temp = this.adjmatrix;
            adjmatrix = new int[temp.length*2][temp.length*2];
            for (int i = 0; i < temp.length; i++){
                for (int j = 0; j < temp.length; j++)
                    this.adjmatrix[i][j] = temp[i][j];
                for (int j = temp.length; j < temp.length*2; j++)
                    this.adjmatri
  • 1
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Dijkstra算法是一种用于有向最短路径算法。使用邻接矩阵实现Dijkstra算法的步骤如下: 1. 初始化:将起点到各个顶点的距离初始化为无穷大,将起点到自身的距离初始化为0。 2. 选择起点:从未处理的顶点中选择距离起点最近的顶点作为当前顶点。 3. 更新距离:对于当前顶点的所有邻接点,如果从起点到当前顶点再到邻接点的距离小于起点到邻接点的距离,则更新起点到邻接点的距离。 4. 标记已处理:将当前顶点标记为已处理。 5. 重复步骤2-4,直到所有顶点都被标记为已处理或者没有可达的顶点。 6. 输出结果:输出起点到各个顶点的最短距离。 邻接矩阵实现Dijkstra算法的时间复杂度为O(n^2),其中n为顶点数。 ### 回答2: 邻接矩阵是一种表示结构的方法,具体而言,若G有n个顶点,则邻接矩阵一个n x n矩阵,其中每个元素表示两个顶点之间的边。在有向中,若从顶点i到顶点j有一条有向边,则邻接矩阵中第i行第j列的元素为1,否则为0。 Dijkstra算法是一种经典的最短路径算法,它可以在带权有向出从一个起点到所有其他点的最短路径Dijkstra算法的基本思想是,维护一个待访问的顶点集合V,初始时只包含起点。对于V中的每个顶点,记录起点到该顶点最短路径长度以及已确定最短路径的所有顶点。在每一轮中,选择V中距离起点最近的顶点u,并将其加入已确定最短路径的集合S。然后,对于u的所有邻居v,如果通过u可以得到比当前路径更短的路径,则更新v的最短路径信息。重复上述过程,直到所有顶点都已被加入S为止。 使用邻接矩阵实现Dijkstra算法的基本思路是,定义两个数组dis和visited,分别记录起点到各个顶点的距离和该顶点是否已被访问。初始时,将起点的dis值设为0,visited值设为true。然后,遍历与起点相邻的顶点,并更新它们的dis值。在每一轮中,选择距离起点最近的未被访问的顶点u,并将visited[u]设为true。然后,依次遍历u的所有邻居v,如果通过u可以得到比当前路径更短的路径,则更新v的dis值。最后,重复进行n次循环,直到所有顶点的dis值都已确定。在实际实现中,可以借助优先队列等数据结构来加速算法的执行。 总的来说,使用邻接矩阵实现Dijkstra算法是一种简单有效的方法,它可以处理中等规模的带权有向。然而,在处理大规模时,邻接矩阵的空间复杂度和时间复杂度都较高,需要使用其他更高效的算法和数据结构来解决。 ### 回答3: Dijkstra算法是一种常见的最短路径算法,在有向中可以使用邻接矩阵实现邻接矩阵是一种二维数组,其中的元素表示两点之间的连接关系,如果两个点之间有连接,那么数组元素的值为连接的权重,否则为无穷大。 首先,需要定义一个类,从而可以将邻接矩阵封装在内部,同时提供相应的函数来实现Dijkstra算法。如下所示: ``` class Graph: def __init__(self, V): self.V = V self.graph = [[0 for column in range(V)] for row in range(V)] def dijkstra(self, src): dist = [float('inf')] * self.V dist[src] = 0 sptSet = [False] * self.V for i in range(self.V): u = self.minDistance(dist, sptSet) sptSet[u] = True for v in range(self.V): if self.graph[u][v] > 0 and sptSet[v] == False and \ dist[v] > dist[u] + self.graph[u][v]: dist[v] = dist[u] + self.graph[u][v] self.printSolution(dist) def minDistance(self, dist, sptSet): min = float('inf') min_index = -1 for v in range(self.V): if dist[v] < min and sptSet[v] == False: min = dist[v] min_index = v return min_index def printSolution(self, dist): for node in range(self.V): print(f"Node {node} distance from source: {dist[node]}") ``` 在主函数中,首先需要创建一个对象,然后按照邻接矩阵的方式设置中边的权重。接着,可以调用Dijkstra算法来计算从源节点到其他所有节点的最短路径长度。最后,输出所有节点的距离值。 代码示例如下: ``` # create graph V = 9 g = Graph(V) # set vertices and edges g.graph = [[0, 4, 0, 0, 0, 0, 0, 8, 0], [4, 0, 8, 0, 0, 0, 0, 11, 0], [0, 8, 0, 7, 0, 4, 0, 0, 2], [0, 0, 7, 0, 9, 14, 0, 0, 0], [0, 0, 0, 9, 0, 10, 0, 0, 0], [0, 0, 4, 14, 10, 0, 2, 0, 0], [0, 0, 0, 0, 0, 2, 0, 1, 6], [8, 11, 0, 0, 0, 0, 1, 0, 7], [0, 0, 2, 0, 0, 0, 6, 7, 0]] # calculate shortest path g.dijkstra(0) ``` 以上就是使用邻接矩阵实现有向最短路径Dijkstra算法的简要介绍。该算法常用于寻找两点之间的最短路径、计算网络中消息传递的时间等问题。当然,如果有向中存在负权边,则需要使用Bellman-Ford算法来解决。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值