成长中。。。

【数据结构与算法】常用的十大算法

常用的十大算法：

文章目录

常用的十大算法：

1.二分查找算法(非递归)：
2.分治算法

2.1分治算法介绍
2.2 分治算法的基本步骤
2.3 分治算法最佳实践-汉诺塔
2.4 动态规划算法

2.4.1应用场景-背包问题
2.4.2 动态规划算法介绍
2.4.3 动态规划算法最佳实践-背包问题
2.4.4 动态规划-背包问题的代码实现

3. KMP算法

3.1 应用场景-字符串匹配问题
3.2 暴力匹配算法
3. 3 KMP 算法介绍

3.3.1 KMP 算法最佳应用-字符串匹配问题

4.贪心算法

4.1 应用场景-集合覆盖问题
4.2 贪心算法介绍
4.3 贪心算法最佳应用-集合覆盖
4.4 贪心算法注意事项和细节

5. 普里姆算法

5.1 应用场景-修路问题
5.2 最小生成树
5.3 普里姆算法介绍
5.4 普里姆算法最佳实践(修路问题)

6.克鲁斯卡尔算法

6.1 应用场景-公交站问题
6.2 克鲁斯卡尔算法介绍
6.3 克鲁斯卡尔算法图解说明
6.4 克鲁斯卡尔最佳实践-公交站问题

7 迪杰斯特拉算法

7.1 应用场景-最短路径问题
7.2 迪杰斯特拉(Dijkstra)算法介绍
7.3 迪杰斯特拉(Dijkstra)算法过程
7.4 迪杰斯特拉(Dijkstra)算法最佳应用-最短路径

8.弗洛伊德算法

8.1 弗洛伊德(Floyd)算法介绍
8.2 弗洛伊德(Floyd)算法图解分析
8.3 弗洛伊德(Floyd)算法最佳应用-最短路径

9. 马踏棋盘算法

9.1 马踏棋盘算法介绍和游戏演示
9.2 马踏棋盘游戏代码实现

1.二分查找算法(非递归)：

代码：

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/21 15:13
 * @version V1.0
 */

/**
 * @author lmy
 * @ClassName BinarySearchNoRecur
 * @Description 二分查找算法（非递归）
 * @date 2020/3/21 15:13
 **/

public class BinarySearchNoRecur {

    public static void main(String[] args) {
        int[] arr = {1, 3, 8, 10, 11, 67, 100};

        binarySearch(arr, 10);
    }

    // 二分查找
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] > target) {
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }
        return -1;
    }

}

2.分治算法

2.1分治算法介绍

分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……
分治算法可以求解的一些经典问题

ü 二分搜索

ü 大整数乘法

ü 棋盘覆盖

ü 合并排序

ü 快速排序

ü 线性时间选择

ü 最接近点对问题

ü 循环赛日程表

ü 汉诺塔

2.2 分治算法的基本步骤

分治法在每一层递归上都有三个步骤：

1) 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题

2) 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题

3) 合并：将各个子问题的解合并为原问题的解。

2.3 分治算法最佳实践-汉诺塔

Ø 汉诺塔游戏的演示和思路分析:

如果是有一个盘， A->C

如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的盘 2. 上面的盘

先把最上面的盘 A->B
把最下边的盘 A->C
把 B 塔的所有盘从 B->C

代码：

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/21 15:44
 * @version V1.0
 */

/**
 * @author lmy
 * @ClassName HannoiTower
 * @Description 分子算法==汉诺塔问题
 * @date 2020/3/21 15:44
 **/

public class HannoiTower {

    public static void main(String[] args) {
        hannoiTower(3, 'A', 'B', 'C');

    }

    // 解决汉诺塔问题
    public static void hannoiTower(int num, char a, char b, char c) {
        if (num == 1) {
            System.out.println("第1个盘从" + a + "->" + c);
        } else {
            hannoiTower(num - 1, a, c, b);
            System.out.println("第" + num + "个盘从" + a + "->" + c);
            hannoiTower(num - 1, b, a, c);
        }
    }

}

2.4 动态规划算法

2.4.1应用场景-背包问题

背包问题：有一个背包，容量为 4 磅，现有如下物品

要求达到的目标为装入的背包的总价值最大，并且重量不超出
要求装入的物品不能重复

2.4.2 动态规划算法介绍

动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法
动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 ( 即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )
动态规划可以通过填表的方式来逐步推进，得到最优解.

2.4.3 动态规划算法最佳实践-背包问题

背包问题：有一个背包，容量为 4 磅，现有如下物品

要求达到的目标为装入的背包的总价值最大，并且重量不超出
要求装入的物品不能重复

思路分析和图解

背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分 01 背包和完全背包(完全背包指的是：每种物品都有无限件可用)
这里的问题属于 01 背包，即每个物品最多放一个。而无限背包可以转化为 01 背包。
算法的主要思想，利用动态规划来解决。每次遍历到的第 i 个物品，根据 w[i]和 v[i]来确定是否需要将该物品放入背包中。即对于给定的 n 个物品，设 v[i]、w[i]分别为第 i 个物品的价值和重量，C 为背包的容量。再令 v[i][j] 表示在前 i 个物品中能够装入容量为 j 的背包中的最大价值。则我们有下面的结果：

图解的分析

2.4.4 动态规划-背包问题的代码实现

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/22 11:33
 * @version V1.0
 */

/**
 * @author lmy
 * @ClassName DynamicDemo
 * @Description 动态规划算法==解决背包问题
 * @date 2020/3/22 11:33
 **/

public class DynamicDemo {

    public static void main(String[] args) {
        int[] w = {1, 4, 3};
        int[] val = {1500, 3000, 2000};
        int m = 4;
        int n = val.length;

        // 记录商品放入的情况
        int[][] path = new int[n + 1][m + 1];

        int[][] v = new int[n + 1][m + 1];
        // 初始化第一行和第一列
        for (int i = 0; i < v.length; i++) {
            v[i][0] = 0;
        }

        for (int i = 0; i < v[0].length; i++) {
            v[0][i] = 0;
        }

        for (int i = 1; i < v.length; i++) {
            for (int j = 1; j < v[0].length; j++) {
                if (w[i - 1] > j) {
                    v[i][j] = v[i - 1][j];
                } else {
//                    v[i][j] = Math.max(v[i - 1][j], val[i - 1] + v[i - 1][j - w[i - 1]]);
                    if (v[i - 1][j] < val[i - 1] + v[i - 1][j - w[i - 1]]) {
                        v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];
                        path[i][j] = 1;
                    } else {
                        v[i][j] = v[i - 1][j];
                    }
                }
            }
        }


        for (int i = 0; i < v.length; i++) {
            for (int j = 0; j < v[i].length; j++) {
                System.out.print(v[i][j] + " ");
            }
            System.out.println();
        }

        int i = path.length - 1;
        int j = path[0].length -1;
        while (i > 0 && j > 0) {
            if (path[i][j] == 1) {
                System.out.printf("第%d个商品放入到背包\n", i);
                j -= w[i - 1];
            }
            i--;
        }

    }



}

3. KMP算法

3.1 应用场景-字符串匹配问题

Ø 字符串匹配问题：：

有一个字符串 str1= ““硅硅谷尚硅谷你尚硅尚硅谷你尚硅谷你尚硅你好””，和一个子串 str2=“尚硅谷你尚硅你”
现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1

3.2 暴力匹配算法

如果用暴力匹配的思路，并假设现在 str1 匹配到 i 位置，子串 str2 匹配到 j 位置，则有:

如果当前字符匹配成功（即 str1[i] == str2[j]），则 i++，j++，继续匹配下一个字符
如果失配（即 str1[i]! = str2[j]），令 i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为 0。
用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量的时间。(不可行!)
暴力匹配算法实现.

代码：

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/23 10:46
 * @version V1.0
 */

/**
 * @author lmy
 * @ClassName ViolenceMatch
 * @Description 暴力匹配算法
 * @date 2020/3/23 10:46
 **/

public class ViolenceMatch {

    public static void main(String[] args) {
        String str1 = "你中有我，我中有你，但你不是我";
        String str2 = "有你";
        int index = violenceMatch(str1, str2);
        System.out.println(index);
    }


    // 暴力匹配
    public static int violenceMatch(String str1, String str2) {
        char[] s1 = str1.toCharArray();
        char[] s2 = str2.toCharArray();

        int s1Len = s1.length;
        int s2Len = s2.length;

        int i = 0;
        int j = 0;
        while (i < s1Len && j < s2Len) {
            if (s1[i] == s2[j]) {
                i++;
                j++;
            } else {
                i = i - (j - 1);
                j = 0;
            }
        }
        // 判断是否匹配成功
        if (j == s2Len) {
            return i - j;
        } else {
            return -1;
        }


    }



}

3. 3 KMP 算法介绍

KMP 是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法
Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP 算法”，常用于在一个文本串 S 内查找一个模式串 P 的出现位置，这个算法由 Donald Knuth、Vaughan Pratt、James H. Morris 三人于 1977 年联合发表，故取这 3 人的姓氏命名此算法.
KMP 方法算法就利用之前判断过信息，通过一个 next 数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过 next 数组找到，前面匹配过的位置，省去了大量的计算时间
参考资料：https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html

3.3.1 KMP 算法最佳应用-字符串匹配问题

Ø 字符串匹配问题：：

有一个字符串 str1= “BBC ABCDAB ABCDABCDABDE”，和一个子串 str2=“ABCDABD”
现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1
要求：使用 KMP 算法完成判断，不能使用简单的暴力匹配算法.

Ø 思路分析图解

\4. 接着比较字符串和搜索词的下一个字符，还是符合。

\5. 遇到 Str1 有一个字符与 Str2 对应的字符不符合。

6.这时候，想到的是继续遍历 Str1 的下一个字符，重复第 1 步。(其实是很不明智的，因为此时 BCD 已经比较过了，没有必要再做重复的工作，一个基本事实是，当空格与 D 不匹配时，你其实知道前面六个字符是”ABCDAB”。 KMP 算法的想法是，设法利用这个已知信息，不要把”搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。)

\7. 怎么做到把刚刚重复的步骤省略掉？可以对 Str2 计算出一张《部分匹配表》，这张表的产生在后面介绍

12.逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动 7 位，这里就不再重复了。

\13.

介绍《部分匹配表》怎么产生的先介绍前缀，后缀是什么

“部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”ABCDABD”为例，

－”A”的前缀和后缀都为空集，共有元素的长度为 0；

－”AB”的前缀为[A]，后缀为[B]，共有元素的长度为 0；

－”ABC”的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度 0；

－”ABCD”的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为 0；

－”ABCDA”的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为”A”，长度为 1；

－”ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为”AB”，

长度为 2；

－”ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD,

D]，共有元素的长度为 0。

代码实现：

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/23 11:32
 * @version V1.0
 */

/**
 * @author lmy
 * @ClassName KMPAlgorithm
 * @Description KMP算法匹配字符串
 * @date 2020/3/23 11:32
 **/

public class KMPAlgorithm {

    public static void main(String[] args) {
        String str1 = "BBC ABCDAB ABCDABCDABDE";
        String str2 = "ABCDABD";
        int[] kmpNext = getKmpNext(str2);
        int index = kmpSearch(str1, str2, kmpNext);
        System.out.println(index);

    }

    public static int kmpSearch(String str1, String str2, int[] next) {


        for (int i = 0, j = 0; i < str1.length(); i++) {
            while (j > 0 && str1.charAt(i) != str2.charAt(j)) {
                j = next[j - 1];
            }

            if (str1.charAt(i) == str2.charAt(j)) {
                j++;
            }
            if (j == str2.length()) {
                return i - j + 1;
            }

        }
        return -1;
    }

    // 获取一个字符串的部分匹配值
    public static int[] getKmpNext(String dest) {
        int[] next = new int[dest.length()];
        next[0] = 0;
        for (int i = 1, j = 0; i < dest.length(); i++) {
            while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
                j = next[j-1];
            }
            if (dest.charAt(i) == dest.charAt(j)) {
                j++;
            }
            next[i] = j;
        }
        return next;
    }


}

4.贪心算法

4.1 应用场景-集合覆盖问题

假设存在下面需要付费的广播台，以及广播台信号可以覆盖的地区。如何选择最少的广播台，让所有的地区都可以接收到信号

4.2 贪心算法介绍

贪婪算法(贪心算法)是指在对问题进行求解时，在每一步选择中都采取最好或者最优**(即最有利)**的选择，从而希望能够导致结果是最好或者最优的算法
贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解)，但是都是相对近似(接近)最优解的结果

4.3 贪心算法最佳应用-集合覆盖

假设存在如下表的需要付费的广播台，以及广播台信号可以覆盖的地区。如何选择最少的广播台，让所有的地区都可以接收到信号

```
 思路分析:
```

Ø 如何找出覆盖所有地区的广播台的集合呢，使用穷举法实现,列出每个可能的广播台的集合，这被称为幂集。假设总的有 n 个广播台，则广播台的组合总共有

2ⁿ -1 个,假设每秒可以计算 10 个子集，如图:

Ø 使用贪婪算法，效率高:

目前并没有算法可以快速计算得到准备的值，使用贪婪算法，则可以得到非常接近的解，并且效率高。选择策略上，因为需要覆盖全部地区的最小集合:
遍历所有的广播电台, 找到一个覆盖了最多未覆盖的地区的电台(此电台可能包含一些已覆盖的地区，但没有关系）
将这个电台加入到一个集合中(比如 ArrayList), 想办法把该电台覆盖的地区在下次比较时去掉。
重复第 1 步直到覆盖了全部的地区分析的图解:

代码实现

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/24 10:39
 * @version V1.0
 */

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

/**
 * @author lmy
 * @ClassName GreedyAlgorithm
 * @Description 贪心算法==>>覆盖问题
 * @date 2020/3/24 10:39
 **/

public class GreedyAlgorithm {
    public static void main(String[] args) {

        HashMap<String, HashSet<String>> broadcasts = new HashMap<String, HashSet<String>>();

        HashSet<String> hashSet1 = new HashSet<String>();
        hashSet1.add("北京");
        hashSet1.add("上海");
        hashSet1.add("天津");

        HashSet<String> hashSet2 = new HashSet<String>();
        hashSet2.add("北京");
        hashSet2.add("广州");
        hashSet2.add("深圳");

        HashSet<String> hashSet3 = new HashSet<String>();
        hashSet3.add("成都");
        hashSet3.add("上海");
        hashSet3.add("杭州");

        HashSet<String> hashSet4 = new HashSet<String>();
        hashSet4.add("天津");
        hashSet4.add("上海");

        HashSet<String> hashSet5 = new HashSet<String>();
        hashSet5.add("杭州");
        hashSet5.add("大连");

        broadcasts.put("K1", hashSet1);
        broadcasts.put("K2", hashSet2);
        broadcasts.put("K3", hashSet3);
        broadcasts.put("K4", hashSet4);
        broadcasts.put("K5", hashSet5);

        HashSet<String> allAreas = new HashSet<>();
        for (Map.Entry<String, HashSet<String>> entry : broadcasts.entrySet()) {
            for (String s : entry.getValue()) {
                allAreas.add(s);
            }
        }

//        for (String allArea : allAreas) {
//            System.out.println(allArea);
//        }

        ArrayList<String> selects = new ArrayList<>();

        HashSet<String> tempSet = new HashSet<String>();

        String maxKey = null;
        while (allAreas.size() != 0) {
            maxKey = null;
            for (String key : broadcasts.keySet()) {
                tempSet.clear();
                HashSet<String> areas = broadcasts.get(key);
                tempSet.addAll(areas);

                tempSet.retainAll(allAreas);
                if (tempSet.size() > 0 && (maxKey == null || tempSet.size() > broadcasts.get(maxKey).size())) {
                    maxKey = key;
                }
            }
            if (maxKey != null) {
                selects.add(maxKey);
                allAreas.removeAll(broadcasts.get(maxKey));

            }
        }
        System.out.println(selects);


    }



}

4.4 贪心算法注意事项和细节

贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解)，但是都是相对近似(接近)最优解的结果
比如上题的算法选出的是 K1, K2, K3, K5，符合覆盖了全部的地区
但是我们发现 K2, K3,K4,K5 也可以覆盖全部地区，如果 K2 的使用成本低于 K1,那么我们上题的 K1, K2, K3, K5 虽然是满足条件，但是并不是最优的.

5. 普里姆算法

5.1 应用场景-修路问题

Ø 看一个应用场景和问题：

1) 有胜利乡有 7 个村庄**(A, B, C, D, E, F, G)** ，现在需要修路把 7 个村庄连通

2) 各个村庄的距离用边线表示**(权)** ，比如 A – B 距离 5 公里

3) 问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短**?** 思路*** 将 10 条边，连接即可，但是总的里程数不是最小**.**

正确的思路，就是尽可能的选择少的路线，并且每条路线最小，保证总里程数最少**.**

5.2 最小生成树

修路问题本质就是就是最小生成树问题，先介绍一下最小生成树**(Minimum Cost Spanning Tree)，简称 MST。给定一个带权的无向连通图,如何选取一棵生成树,使树上所有边上权的总和为最小,**这叫最小生成树

1) N 个顶点，一定有 N-1 条边

2) 包含全部顶点

3) N-1 条边都在图中

4) 举例说明**(如图**

5) 求最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法

5.3 普里姆算法介绍

普利姆(Prim)算法求最小生成树，也就是在包含 n 个顶点的连通图中，找出只有(n-1)条边包含所有 n 个顶点的连通子图，也就是所谓的极小连通子图

普利姆的算法如下:

设 G=(V,E)是连通网，T=(U,D)是最小生成树，V,U 是顶点集合，E,D 是边的集合
若从顶点 u 开始构造最小生成树，则从集合 V 中取出顶点 u 放入集合 U 中，标记顶点 v 的 visited[u]=1
若集合 U 中顶点 ui 与集合 V-U 中的顶点 vj 之间存在边，则寻找这些边中权值最小的边，但不能构成回路，将顶点 vj 加入集合 U 中，将边（ui,vj）加入集合 D 中，标记 visited[vj]=1
重复步骤②，直到 U 与 V 相等，即所有顶点都被标记为访问过，此时 D 中有 n-1 条边
提示: 单独看步骤很难理解，我们通过代码来讲解，比较好理解.
图解普利姆算法

5.4 普里姆算法最佳实践(修路问题)

有胜利乡有 7 个村庄(A, B, C, D, E, F, G) ，现在需要修路把 7 个村庄连通
各个村庄的距离用边线表示(权) ，比如 A – B 距离 5 公里
问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短?

代码：

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/25 11:58
 * @version V1.0
 */

import java.util.Arrays;

/**
 * @author lmy
 * @ClassName PrimAlgorithm
 * @Description 普里姆算法===》最小生成树
 * @date 2020/3/25 11:58
 **/

public class PrimAlgorithm {

    public static void main(String[] args) {
        char[] data = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int verxs = data.length;
        int[][] weight = new int[][]{
                {10000, 5, 7, 10000, 10000, 10000, 2},
                {5, 10000, 10000, 9, 10000, 10000, 3},
                {7, 10000, 10000, 10000, 8, 10000, 10000},
                {10000, 9, 10000, 10000, 10000, 4, 10000},
                {10000, 10000, 8, 10000, 10000, 5, 4},
                {10000, 10000, 10000, 4, 5, 10000, 6},
                {2, 3, 10000, 10000, 4, 6, 10000}
        };

        MGraph graph = new MGraph(verxs);
        MinTree minTree = new MinTree();
        minTree.createGraph(graph, verxs, data, weight);
        minTree.showGraph(graph);
        minTree.prim(graph, 0);

    }

}

class MinTree {
    // 创建图的邻接矩阵
    public void createGraph(MGraph graph, int verxs, char data[], int[][] wetght) {
        int i, j;
        for (i = 0; i < verxs; i++) {
            graph.data[i] = data[i];
            for (j = 0; j < verxs; j++) {
                graph.weight[i][j] = wetght[i][j];
            }
        }
    }
    
    // 显示图的邻接矩阵
    public void showGraph(MGraph graph) {
        for (int[] ints : graph.weight) {
            System.out.println(Arrays.toString(ints));
        }
    }


    /**
     * 编写普里姆算法
     * @param graph
     * @param v 第一个顶点
     */
    public void prim(MGraph graph, int v) {
        int visit[] = new int[graph.verxs];
        visit[v] = 1;
        int h1 = -1;
        int h2 = -1;
        int minWeight = 10000;
        for (int k = 1; k < graph.verxs; k++) {

            for (int i = 0; i < graph.verxs; i++) {
                for (int j = 0; j < graph.verxs; j++) {
                    if (visit[i] == 1 && visit[j] == 0 && graph.weight[i][j] < minWeight) {
                        minWeight = graph.weight[i][j];
                        h1 = i;
                        h2 = j;
                    }
                }
            }
            System.out.println("边<" + graph.data[h1] + "," + graph.data[h2] + "> 权值：" + minWeight);
            // 标记h2已访问
            visit[h2] = 1;
            minWeight = 10000;
        }

    }



}

// 创建一个图
class MGraph {
    // 表示图的节点个数
    int verxs;
    // 存放节点数据
    char[] data;
    // 存放边
    int[][] weight;

    public MGraph(int verxs) {
        this.verxs = verxs;
        data = new char[verxs];
        weight = new int[verxs][verxs];
    }



}

6.克鲁斯卡尔算法

6.1 应用场景-公交站问题

看一个应用场景和问题：

某城市新增 7 个站点(A, B, C, D, E, F, G) ，现在需要修路把 7 个站点连通
各个站点的距离用边线表示(权) ，比如 A – B 距离 12 公里
问：如何修路保证各个站点都能连通，并且总的修建公路总里程最短?

6.2 克鲁斯卡尔算法介绍

克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。
基本思想：按照权值从小到大的顺序选择 n-1 条边，并保证这 n-1 条边不构成回路
具体做法：首先构造一个只含 n 个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止

6.3 克鲁斯卡尔算法图解说明

以城市公交站问题来图解说明克鲁斯卡尔算法的原理和步骤：

更多 Java –大数据 –前端 –python 人工智能 -区块链资料下载，可访问百度：尚硅谷官网第 391页

边的权值最小，因此将它加入到最小生成树结果 R 中。第 2 步：将边加入 R 中。

上一步操作之后，边的权值最小，因此将它加入到最小生成树结果 R 中。第 3 步：将边加入 R 中。

上一步操作之后，边的权值最小，因此将它加入到最小生成树结果 R 中。第 4 步：将边加入 R 中。

上一步操作之后，边的权值最小，但会和已有的边构成回路；因此，跳过边。同理，跳过边。将边加入到最小生成树结果 R 中。

第 5 步：将边加入 R 中。

上一步操作之后，边的权值最小，因此将它加入到最小生成树结果 R 中。第 6 步：将边加入 R 中。

上一步操作之后，边的权值最小，但会和已有的边构成回路；因此，跳过边。同理，跳过边。将边加入到最小生成树结果 R 中。

此时，最小生成树构造完成！它包括的边依次是：** **。

根据前面介绍的克鲁斯卡尔算法的基本思想和做法，我们能够了解到，克鲁斯卡尔算法重点需要解决的以下两个问题：

问题一对图的所有边按照权值大小进行排序。

问题二将边添加到最小生成树中时，怎么样判断是否形成了回路。

问题一很好解决，采用排序算法进行排序即可。

问题二，处理方式是：记录顶点在"最小生成树"中的终点，顶点的终点是"在最小生成树中与它连通的最大顶点"。然后每次需要将一条边添加到最小生存树时，判断该边的两个顶点的终点是否重合，重合的话则会构成回路。

6.4 克鲁斯卡尔最佳实践-公交站问题

看一个公交站问题：

有北京有新增 7 个站点(A, B, C, D, E, F, G) ，现在需要修路把 7 个站点连通
各个站点的距离用边线表示(权) ，比如 A – B 距离 12 公里
问：如何修路保证各个站点都能连通，并且总的修建公路总里程最短?
```
    代码实现和注解
```

package com.data.alg;
/**
 * @Project data_structures
 * @Package com.data.alg
 * @author lmy
 * @date 2020/3/26 10:53
 * @version V1.0
 */

import java.util.Arrays;

/**
 * @author lmy
 * @ClassName KruskalCase
 * @Description 克鲁斯卡尔算====》最小生成树
 * @date 2020/3/26 10:53
 **/

public class KruskalCase {

    private int edgeNum;
    private char[] vertexs;
    private int[][] matrix;
    private static final int INF = Integer.MAX_VALUE;


    public static void main(String[] args) {
        char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int matrix[][] = {
                {0, 12, INF, INF, INF, 16, 14},
                {12, 0, 10, INF, INF, 7, INF},
                {INF, 10, 0, 3, 5, 6, INF},
                {INF, INF, 3, 0, 4, INF, INF},
                {INF, INF, 5, 4, 0, 2, 8},
                {16, 7, 6, INF, 2, 0, 9},
                {14, INF, INF, INF, 8, 9, 0}
        };
        KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
        kruskalCase.print();
//        EdData[] edges = kruskalCase.getEdges();
//        System.out.println("排序前：" + Arrays.toString(edges));
//        kruskalCase.sortEdges(edges);
//        System.out.println("排序后:" + Arrays.toString(edges));
        kruskalCase.kruskalMethod();


    }

    public KruskalCase(char[] vertexs, int[][] matrix) {
        int vlen = vertexs.length;
        this.vertexs = new char[vlen];
        for (int i = 0; i < vertexs.length; i++) {
            this.vertexs[i] = vertexs[i];
        }
        this.matrix = new int[vlen][vlen];
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                this.matrix[i][j] = matrix[i][j];
            }
        }

        for (int i = 0; i < vlen; i++) {
            for (int j = i + 1; j < vlen; j++) {
                if (this.matrix[i][j] != INF) {
                    edgeNum++;
                }
            }
        }
    }


    // 打印
    public void print() {
        System.out.println("邻接矩阵为：\n");
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = 0; j < vertexs.length; j++) {
                System.out.printf("%12d\t", matrix[i][j]);
            }
            System.out.println();
        }
    }

    // 克鲁斯算法
    public void kruskalMethod() {
        int index = 0;
        // 保存终点
        int[] ends = new int[edgeNum];
        EdData[] rets = new EdData[edgeNum];

        // 获取图中所有边的集合
        EdData[] edges = getEdges();
        System.out.println("获取图边的集合：" + Arrays.toString(edges) + "共" + edges.length);

        // 排序
        sortEdges(edges);

        // 遍历edges
        for (int i = 0; i < edgeNum; i++) {
            int p1 = getPosition(edges[i].start);
            int p2 = getPosition(edges[i].end);
            int m = getEnd(ends, p1);
            int n = getEnd(ends, p2);
            if (m != n) {
                // 没有构成回路
                ends[m] = n;
                rets[index++] = edges[i];
            }
        }

        // 打印
        System.out.println("最小生成树为：");
        for (int i = 0; i < index; i++) {
            System.out.println(rets[i]);
        }

    }




    // 对边排序
    public void sortEdges(EdData[] edData) {
        for (int i = 0; i < edData.length - 1; i++) {
            for (int j = 0; j < edData.length - 1 - i; j++) {
                if (edData[j].weight > edData[j + 1].weight) {
                    EdData tmp = edData[j];
                    edData[j] = edData[j + 1];
                    edData[j + 1] = tmp;
                }
            }
        }
    }


    // 返回顶点对应的下标
    private int getPosition(char ch) {
        for (int i = 0; i < vertexs.length; i++) {
            if (vertexs[i] == ch) {
                return i;
            }
        }
        return -1;
    }

    // 获取图中边，放到EdData数组中
    private EdData[] getEdges() {
        int index = 0;
        EdData[] edges = new EdData[edgeNum];
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = i + 1; j < vertexs.length; j++) {
                if (matrix[i][j] != INF) {
                    edges[index++] = new EdData(vertexs[i], vertexs[j], matrix[i][j]);
                }
            }
        }
        return edges;
    }


    // 获取下标为i的顶点的终点
    private int getEnd(int[] ends, int i) {
        while (ends[i] != 0) {
            i = ends[i];
        }
        return i;
    }



}


class EdData {
    char start;
    char end;
    int weight;

    public EdData(char start, char end, int weight) {
        this.start = start;
        this.end = end;
        this.weight = weight;
    }


    @Override
    public String toString() {
        return "<" +
                "start=" + start +
                ", end=" + end +
                "> =" + weight +
                '}';
    }
}

7 迪杰斯特拉算法

7.1 应用场景-最短路径问题