十大常用算法之地杰斯特拉算法

最新推荐文章于 2023-10-24 21:14:48 发布
最新推荐文章于 2023-10-24 21:14:48 发布
阅读量598 收藏 4
点赞数
分类专栏： # 算法笔记 文章标签： 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46635575/article/details/121692675
版权

十大常用算法的完整实现

一、二分查找算法：https://blog.csdn.net/weixin_46635575/article/details/121532149
二、分治算法：https://blog.csdn.net/weixin_46635575/article/details/121532941
三、动态规划算法：https://blog.csdn.net/weixin_46635575/article/details/121534074
四、KMP算法：https://blog.csdn.net/weixin_46635575/article/details/121590510
五、贪心算法：https://blog.csdn.net/weixin_46635575/article/details/121626626
六、普利姆算法：https://blog.csdn.net/weixin_46635575/article/details/121653256
七、克鲁斯卡尔算法：https://blog.csdn.net/weixin_46635575/article/details/121670374
八、地杰斯特拉算法：https://blog.csdn.net/weixin_46635575/article/details/121692675
九、佛洛依德算法：https://blog.csdn.net/weixin_46635575/article/details/121714678
十、马踏棋盘算法（周游骑士算法）：https://blog.csdn.net/weixin_46635575/article/details/121716596

1、基本介绍

（1）应用场景

在这里插入图片描述

（2）介绍

在这里插入图片描述
回忆一下我们的图的广度优先和深度优先
在这里插入图片描述

  • 广度优先是从一层一层的访问：所以是12345678
  • 深度优先是先走到底，然后回到起点进行重新查找，如果还是不是很理解的话，建议你去看一下我主页的图的算法的文章。

在这里插入图片描述

  • v就是我们例子中的G点，Dis里面记录的是v到图中各个节点的距离

（3）图解我们的题目

在这里插入图片描述

  • 当以G开始走一遍后
    在这里插入图片描述
    在这里插入图片描述
    当G访问后，接下来开始访问A开始访问。这时候三个数组也是要进行更新的，这时候的出发顶点任然是G点，只是以A点访问而已，不然我们无法记录G到各个顶点的距离。

  • 需要创建的数组
    在这里插入图片描述

2、代码编写

来看我们分析写代码的顺序
在这里插入图片描述
在这里插入图片描述

  • 首先我要去编写初始化图的一个类，并且初始化图
  • 第二步我是要完成目的1
  • 第三步我们要完成目的2

（1）先初始化我们的图

  • 这个到后面也是很重要的，所以请把这里看懂了，挺简单的
package cn.mldn.dijkstra;

import java.util.Arrays;

public class DijkstraAlgorithm {
    public static void main(String[] args) {
        //先初始化我们的图
        char[] vertex = {'A','B','C','D','E','F','G'};
        //领接矩阵
        int[][] matrix = new int[vertex.length][vertex.length];
        final  int N = 65535;//表示不可连接
        matrix[0] =new int[]{N,5,7,N,N,N,2};
        matrix[1] =new int[]{5,N,N,9,N,N,3};
        matrix[2] =new int[]{7,N,N,N,8,N,N};
        matrix[3] =new int[]{N,9,N,N,N,4,2};
        matrix[4] =new int[]{N,N,8,N,N,5,4};
        matrix[5] =new int[]{N,N,N,4,5,N,6};
        matrix[6] =new int[]{2,3,N,N,4,6,N};

        //这是一部分的测试
        Graph graph = new Graph(vertex, matrix);
        graph.showGraph();
    }
}


class Graph {
    private char[] vertex;//存放顶点数组
    private int[][] matrix;//领接矩阵

    public Graph(char[] vertex,int[][] matrix) {
        this.vertex = vertex;
        this.matrix = matrix;
    }

    //显示图
    public void showGraph() {
        for (int[] link: matrix) {
            System.out.println(Arrays.toString(link));
        }
    }
}

（2）完成目的1

  • 首先要去看VisitedVertex 类的所有方法
  • 然后再去看我们增加在Graph图里面的方法
import java.util.Arrays;

public class DijkstraAlgorithm {
    public static void main(String[] args) {
        //先初始化我们的图
        char[] vertex = {'A','B','C','D','E','F','G'};
        //领接矩阵
        int[][] matrix = new int[vertex.length][vertex.length];
        final  int N = 65535;//表示不可连接
        matrix[0] =new int[]{N,5,7,N,N,N,2};
        matrix[1] =new int[]{5,N,N,9,N,N,3};
        matrix[2] =new int[]{7,N,N,N,8,N,N};
        matrix[3] =new int[]{N,9,N,N,N,4,2};
        matrix[4] =new int[]{N,N,8,N,N,5,4};
        matrix[5] =new int[]{N,N,N,4,5,N,6};
        matrix[6] =new int[]{2,3,N,N,4,6,N};

        //这是一部分的测试
        Graph graph = new Graph(vertex, matrix);
        graph.showGraph();


        //第二部分的测试
        graph.dsj(6);
    }
}

//表示已经访问过的集合
class VisitedVertex {
    //记录各个顶点是否访问过1表示已经访问过，0表没有访问
    public int[] already_arr;

    //每个下标对应的值为前一个顶点的下标，会动态更新
    public int[] pre_visited;

    //记录出发点到其他所有节点的距离，比如G为出发点，就会记录到其他顶点的距离，会动态更新，求的最短距离就会放到dis里面
    public int[] dis;

    //构造器

    /**
     *
     * @param length 你要给我长度
     * @param index 你是从那个顶点开始处理的:即出发顶点
     */
    public VisitedVertex(int length,int index) {
        this.already_arr = new int[length];
        this.pre_visited = new int[length];
        this.dis = new int[length];
        //初始化dis数组，除了自己那个点为0
        Arrays.fill(dis,65535);
        this.already_arr[index] = 1;//设置出发顶点被访问过
        this.dis[index] = 0;
    }

    /**
     * 判断index顶点是否被访问过
     * @param index
     * @return 被访问过就是true
     */
    public boolean in(int index) {
        return already_arr[index] == 1;
    }

    /**
     * 更新出发节点到index顶点的距离【对应dis数组】
     * @param index
     * @param len
     */
    public void updateDis(int index,int len) {
        dis[index] = len;
    }

    /**
     * 更新pre顶点的前驱为index的节点【对应我们的pre_visited】
     * @param pre
     * @param index
     */
    public void updatePre(int pre,int index) {
        pre_visited[pre] = index;
    }

    /**
     * 返回出发顶点到index的距离【对应我们的dis数组】
     * @param index
     */
    public int getDis(int index) {
        return dis[index];
    }


}



class Graph {
    private char[] vertex;//存放顶点数组
    private int[][] matrix;//领接矩阵

    public Graph(char[] vertex,int[][] matrix) {
        this.vertex = vertex;
        this.matrix = matrix;
    }

    //显示图
    public void showGraph() {
        for (int[] link: matrix) {
            System.out.println(Arrays.toString(link));
        }
    }

    private VisitedVertex vv;//表示已经访问的顶点的集合


    /**
     * 地杰斯特拉算法
     * @param index 表示出发顶点的下标
     */
    public void dsj(int index) {
        vv = new VisitedVertex(vertex.length,index);
        update(index);//更新index顶点到周围顶点的距离和前驱顶点
    }

    //更新index下标顶点到周围顶点的距离和周围顶点的前驱顶点
    private void update(int index) {
        int len = 0;
        //根据遍历我们的领接矩阵，即matrix[index]这一行
        for (int i = 0; i < matrix[index].length; i++) {
            //这时候的len表示，出发点到index顶点的距离 + 从index顶点到j顶点的距离
            len = vv.getDis(index) + matrix[index][i];
            //如果i这个节点没有被访问过，并且len小于出发节点到j顶点的距离，就需要更新
            if (!vv.in(i) && len < vv.getDis(i)) {
                vv.updatePre(i,index);//更新i这个节点的前驱节点为index顶点
                vv.updateDis(i,len);//更新出发顶点到i顶点的距离
            }
        }
    }
}

（3）完成目的2

完成上面，就相当于完成了过程图中的目的1，接下来完成目的2

  • 首先在我们的VisitedVertex追加如下方法
/**
     * 继续选择并返回新的访问顶点，比如这里的G完后，就要A作为新的访问顶点【不是以这个为出发点】
     * @return
     */
    public int updateArr() {
        int min = 65535;
        int index = 0;
        for (int i = 0; i < already_arr.length; i++) {
            if (already_arr[i] == 0 && dis[i] < min) {
                min = dis[i];
                index = i;
            }
        }
        //同时更新index顶点被访问过
        already_arr[index] = 1;
        return index;
    }

    
    //用于后面的显示
    public void show() {
        System.out.println("============================");
        for (int i: already_arr) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("****************************");
        for (int i: pre_visited) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("----------------------------");
        for (int i: dis) {
            System.out.print(i + " ");
        }
    }
  • 然后修改我们的的MGraph里面的djs方法和追加我们的show方法
/**
     * 地杰斯特拉算法
     * @param index 表示出发顶点的下标
     */
    public void dsj(int index) {
        vv = new VisitedVertex(vertex.length,index);
        update(index);//更新index顶点到周围顶点的距离和前驱顶点

        for (int i = 0; i < vertex.length; i++) {
            index = vv.updateArr();//选择并返回新的访问顶点
            update(index);//更新index顶点到周围顶点的距离和前驱顶点
        }
    }
    
    
    //用于后续的显示
    public void djsShow() {
        vv.show();
    }
同学郑学习
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
地杰斯特拉算法
10-11
求两个节点的最短距离，应用了地界斯特拉算法，，，，，，，，，，，，，
算法之迪杰斯特拉（dijkstra）非常详细介绍
热门推荐
PRML_MAN的博客
03-07 8万+
迪杰斯特拉（dijkstra）算法是单源最短路径问题的求解方法。单源最短路径就在给出一个固定网络，指定一个原点s，一个目标点e，求这两个点之间的最短路径。举个栗子来理解一下。 小明上学的时候，从家到学校的道路非常多，小明为了减少路上骑车的时间，因此，想找出一个最短的路径。他构造一个网络图，如下： 小明是一个很喜欢动脑筋的同学，他开始研究如何才能找出最优的路径呢？ 1）所有的点到家的距离都进行初始化： 2）每次选择距离家最短的一个点，然后用这个点的距离更新其他相邻点到家的距离，如果比当前的点小，则更新节点
程序员常用10种算法
天问的博客
03-05 1502
程序员常用10种算法下篇普里姆算法应用场景---修路最小生成树算法介绍克鲁斯卡尔算法应用场景--公交站问题(最小生成树求解)算法介绍并查集克鲁斯卡尔代码迪杰斯特拉算法应用场景-最短路径问题算法介绍代码实现参考文献 普里姆算法 应用场景—修路 有胜利乡有 7 个村庄(A, B, C, D, E, F, G) ，现在需要修路把 7 个村庄连通 各个村庄的距离用边线表示(权) ，比如 A – B 距离 5 公里 问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短? 正确的思路，就是尽可能的选择少的
最新十大排序算法详细讲解，以及各种应用场景
小猪向前冲
07-31 7316
十大排序算法汇总 比较和非比较的区别 常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。 在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)...
数据结构--迪杰斯特拉（Dijkstra）算法
最新发布
m0_74939592的博客
10-24 6342
迪杰斯特拉算法 ，建议收藏 ，反复观看。
迪杰斯特拉(Dijkstra)算法
xiaoxi_hahaha的博客
11-29 6万+
一 算法介绍 迪杰斯特拉算法是由荷兰计算机科学家在1956年发现的算法，此算法使用类似广度优先搜索的方法解决了带权图的单源最短路径问题。它是一个贪心算法。 二 核心思想 1. 选定一个点，这个点满足两个条件：1.未被选过，2.距离最短 2. 对于这个点的所有邻近点去尝试松弛 三 算法步骤 首先，可以设置两个集合分别是A和B，A用来存放已经求出最短路径的点，B用来存放还未计算出最短路径的点，接下来就可以开始做题啦！！！ 我们从图中任选一点来解题，假设我们将源点source选择..
最短路(地杰斯特拉算法）.cpp
07-26
迪杰斯特拉算法教学。内附迪杰斯特拉算法的程序
C# 地杰斯特拉算法 求最短路径
04-09
C# 地杰斯特拉算法 求最短路径 C# 地杰斯特拉算法 求最短路径 C# 地杰斯特拉算法 求最短路径
地杰斯特拉的贪婪思想的A-star算法计算出来最短路径，车辆路径长短和车辆速度两个维度进行了分批调度出发时间，matlab源码
03-16
地杰斯特拉的贪婪思想的A-star算法计算出来最短路径，车辆路径长短和车辆速度两个维度进行了分批调度出发时间，matlab源码
Python实现迪杰斯特拉算法过程解析
12-16
一、 迪杰斯特拉算法思想 Dijkstra算法主要针对的是有向图的单元最短路径问题，且不能出现权值为负的情况！Dijkstra算法类似于贪心算法，其应用根本在于最短路径的最优子结构性质。 最短路径的最优子结构性质： ...
第杰斯特算法 最短路
09-08
很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西 很不错的 东西
最短路径——迪杰斯特拉算法
m0_72579201的博客
02-10 2727
日常生活中常常涉及最短路径问题，如在一个城市交通网中，如何选取从起点到达终点的路径，才能使这一趟旅程的路程最短？或所需时间最少？或所需交通费用最低？诸如此类问题都可以抽象为求解图的最短路径问题。我们把图的顶点表示为城市的交通站点，边表示交通站点间的路径，边的权值表示为交通站点间的路径的距离、所需时间或费用等等，则上述问题放映到图上就是，如何求解图顶点间权值之和最小的路径。
迪杰斯特拉算法详解
dyx916_的博客
05-26 982
迪杰斯特拉算法的定义、逻辑和实现
算法之迪杰特斯拉（dijkstra）非常详细介绍
临风暖阳的博客
04-18 649
算法之迪杰特斯拉详细介绍
数据结构——迪杰斯特拉（Dijkstra）算法
qq_51231048的博客
10-31 1万+
迪杰斯特拉算法又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 以下是数据结构中关于迪杰斯特拉算法的操作（编程风格参考严蔚敏版数据结构）。
数据结构 -最短路径dijkstra（迪杰斯特拉）算法讲解及代码实现
weixin_73612682的博客
05-22 2946
迪杰斯特拉算法是一种广义的贪心算法，求出局部最优解，再去求全局最优解。
你居然不会狄杰斯特算法？惊了！
althumi的博客
04-26 504
目录简单介绍Bellman-Ford算法他的优点他的缺点Dijstra算法思想优点与缺点他的缺点他的优点优化插入（更新）取出最后感想 简单介绍Bellman-Ford算法 定义： d[i]:=从s到i的最短距离d[i]:=从s到i的最短距离d[i]:=从s到i的最短距离 初始化： d[s]=0,d[i]=INF,i∈Vd[s]=0,d[i]=INF,i \in Vd[s]=0,d[i]=INF,i∈V 利用递推式： d[i]=min{d[j]+(从j到i的权重)∣e=(i,j)∈E}d[i]=min\{
算法系列——迪杰斯特拉算法（Dijkstra）
lzh1366的博客
08-20 1万+
本系列旨在用简单的人话讲解算法，尽可能避免晦涩的定义，读者可以短时间内理解算法原理及应用细节。我在努力！ 本篇文章编程语言为Python，供参考。 迪杰斯特拉算法（Dijkstra） 典型最短路径算法。用于计算一个节点到其他节点的最短路径。 基本原理：从起始点出发，重复寻找当前距离起始点最近的且未访问过的结点，然后利用该结点更新距离数组，直到访问过全部结点为止，最终的距离数组即为起始点到其余个点的最短路径距离。 1. 邻接矩阵构建 基本用途：用一个二维数组存放两两结点之间的距离或权..
matlab地杰斯特拉算法
10-17
Dijkstra算法是一种用于解决带权重图的单源最短路径问题的算法。它的基本思想是从起点开始，每次选择当前最短路径的节点进行扩展，直到扩展到终点或者无法继续扩展为止。在实现过程中，可以使用优先队列来维护当前最短路径的节点。 在Matlab中，可以使用graph对象和shortestpath函数来实现Dijkstra算法。具体步骤如下： 1. 创建一个graph对象，表示带权重的图。可以使用addnode和addedge方法来添加节点和边，并使用Weights属性来设置边的权重。 2. 使用shortestpath函数来计算起点到终点的最短路径。该函数的输入参数为graph对象、起点和终点的索引，输出参数为最短路径的节点序列和路径长度。 下面是一个简单的示例代码： ```matlab % 创建一个带权重的图 G = graph([1 1 2 2 3 4 4 5], [2 3 3 4 5 5 6 6], [2 1 3 9 4 2 7 8]); % 计算起点到终点的最短路径 [startNode, endNode] = deal(1, 6); [shortestPath, pathLength] = shortestpath(G, startNode, endNode); % 输出结果 fprintf('Shortest path from node %d to node %d:\n', startNode, endNode); fprintf('%d -> ', shortestPath(1:end-1)); fprintf('%d\n', shortestPath(end)); fprintf('Path length: %f\n', pathLength); ``` 输出结果为： ``` Shortest path from node 1 to node 6: 1 -> 2 -> 4 -> 6 Path length: 17.000000 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值