Java数据结构与算法（十三）：程序员常用的10种算法

最新推荐文章于 2023-06-09 09:40:27 发布

红枫忆梦

最新推荐文章于 2023-06-09 09:40:27 发布

阅读量662

点赞数

分类专栏：数据结构与算法文章标签：数据结构 java 算法

本文链接：https://blog.csdn.net/houwanle/article/details/110746745

版权

数据结构与算法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1. 二分查找算法（非递归）

1.1 基本介绍

二分查找法只适用于从有序数列中进行查找（比如数字和字母等），将数列排序后再进行查找；
二分查找法的运行时间为对数时间O(log₂ n），即查找到需要的目标位置最多只需要log₂ n步，假设从[0,99]的队列（100个数，即n=100）中寻到目标数30，则需要查找步数为 log₂ 100，即最多需要查找 7 次（2^6 < 100 < 2^7)

1.2 代码实现

package com.lele.algorithm.binarysearchnorecursion;

/**
 * author: hwl
 * date: 2020/12/6 16:47
 * version: 1.0.0
 * modified by:
 * description: 二分查找（非递归实现）
 */
public class BinarySearchNoRecur {

    public static void main(String[] args) {

        // 测试
        int[] arr = {1,3,8,10,11,67,100};
        int index = binarySearch(arr, 100);
        System.out.println("index=" + index);
    }

    /**
     * 二分查找的非递归实现
     * @param arr  待查找的数组  arr是升序排序
     * @param target  需要查找的值
     * @return  返回对应下标， -1表示没有找到
     */
    public static int binarySearch(int[] arr, int target) {

        int left = 0;
        int right = arr.length - 1;
        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 分治算法的基本步骤

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

分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题；
合并：将各个子问题的解合并为原问题的解；

2.3 分治算法设计模式

在这里插入图片描述

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

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序放着64片黄金原盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个原盘。

思路分析：

如果是有一个盘， A->C；如果有 n>=2 情况，可以看作是两个盘：1.最下边的盘；2.上面的盘；
先把最上面的盘 A->B；
把最下边的盘 A->C；
把B塔的所有盘从 B->C；

代码实现

package com.lele.algorithm.dac;

/**
 * author: hwl
 * date: 2020/12/6 20:59
 * version: 1.0.0
 * modified by:
 * description: 汉诺塔
 */
public class Hanoitower {

    public static void main(String[] args) {
        hanoiTower(5, 'A', 'B', 'C');
    }

    /**
     * 汉诺塔的移动方法
     * 使用分治算法
     * @param num
     * @param a
     * @param b
     * @param c
     */
    public static void hanoiTower(int num, char a, char b, char c) {
        // 如果只有一个盘
        if (num == 1) {
            System.out.println("第1个盘从 " + a + "->" + c);
        } else {
            // 如果有n >= 2情况，则总是可以看作是两个盘：1.最下面的一个盘；2.上面的所有盘
            // 1. 先把最上面的所有盘 A->B，移动过程会使用到C
            hanoiTower(num - 1, a, c, b);
            // 2.把最下边的盘 A->C
            System.out.println("第" + num + "个盘从 " + a + "->" + c);
            // 3.把B塔的所有盘从 B->C，移动过程用到A塔
            hanoiTower(num - 1, b, a, c);
        }
    }
}

3. 动态规划算法

3.1 基本介绍

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

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

背包问题：有一个背包，容量为4磅，现有如下物品：
在这里插入图片描述

要求达到的目标为装入的背包的总价值最大，并且重量不超出背包的最大容量；
要求装入的物品不能重复；
背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分01背包和完全背包（完全背包指的是：每种物品都有无限件可用）；
这里的问题属于01背包，即每个物品最多放一个。而无限背包可以转化为01背包；

3.3 代码实现

package com.lele.algorithm.dynamic;

/**
 * author: hwl
 * date: 2020/12/7 20:27
 * version: 1.0.0
 * modified by:
 * description:
 */
public class KnapsackProblem {

    public static void main(String[] args) {

        int[] w = {1,4,3};// 物品的重量
        int[] val = {1500, 3000, 2000};// 物品的价值
        int m = 4; // 背包的容量
        int n = val.length; // 物品的个数

        // 创建二维数组
        // v[i][j] 表示在前i个物品中能够装入容量为j的背包中的最大价值
        int[][] v = new int[n+1][m+1];

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

        // 初始化第一行和第一列，这里在本程序中，可以不去处理，因为默认就是0
        for (int i = 0; i < v.length; i++) {
            v[i][0] = 0; // 将第一列设置为0
        }

        for (int i = 0; i < v[0].length; i++) {
            v[0][i] = 0; // 将第一行设置为0
        }

        // 根据前面得到公式来动态规划处理
        for (int i = 1; i < v.length; i++) {// 不处理第一行 i是从1开始的
            for (int j = 1; j < v[0].length; j++) {// 不处理第一列， j是从1开始的
                if (w[i-1] > j) {//因为i是从1开始的，所以w[i]修改成w[i-1]
                    v[i][j] = v[i-1][j];
                } else {
                    // 说明：
                    // 因为我们的i 从1开始的，因此公式需要调整
//                    v[i][j] = Math.max(v[i-1][j], val[i-1]+v[i-1][j-w[i-1]]);

                    // 为了记录商品存放到背包的情况，不能直接使用上面的公式，需要使用if-else来体现
                    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
                        path[i][j] = 1;
                    } else {
                        v[i][j] = v[i-1][j];
                    }
                }
            }
        }

        // 输出v
        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();
        }

        System.out.println("===============================");
        // 输出最后我们放入的商品
        // 遍历path,这样输出会把所有的放入情况都得到，其实我们只需要最后的放入
//        for (int i = 0; i < path.length; i++) {
//            for (int j = 0; j < path[i].length; j++) {
//                if (path[i][j] == 1) {
//                    System.out.printf("第%d个商品放入到背包\n", i);
//                }
//            }
//        }

        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--;
        }
    }
}

4. KMP算法

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

字符串匹配问题：
有一个字符串 str1=“I like Java very much!”，和一个子串 str2=“Java”，现在要判断 str1 是否含有 str2，如果存在，就返回第一次出现的位置，如果没有，则返回-1；

4.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.lele.algorithm.kmp;

/**
 * author: hwl
 * date: 2020/12/8 7:17
 * version: 1.0.0
 * modified by:
 * description: 暴力匹配
 */
public class ViolenceMatch {

    public static void main(String[] args) {
        String str1 = "I like Java very much!";
        String str2 = "Java";
        System.out.println("index=" + violenceMatch(str1, str2));
    }

    /**
     * 暴力匹配算法实现
     * @param str1
     * @param str2
     * @return
     */
    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;// i索引指向s1
        int j = 0;// j索引指向s2
        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;
        }
    }

4.3 KMP算法介绍

KMP算法是利用之前判断过的信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到，前面匹配过的位置，省去了大量的计算时间。

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

有一个字符串 str1=“BBC ABCDAB ABCDABCDABDE”，和一个子串 str2=“ABCDABD”，现在要判断 str1 是否含有 str2 ，如果存在，就返回第一次出现的位置，如果没有，则返回-1。使用KMP算法完成。
在这里插入图片描述

代码实现

package com.lele.algorithm.kmp;

import java.util.Arrays;

/**
 * author: hwl
 * date: 2020/12/8 20:51
 * version: 1.0.0
 * modified by:
 * description: KMP算法
 */
public class KMPAlgorithm {

    public static void main(String[] args) {
        String str1 = "BBC ABCDAB ABCDABCDABDE";
        String str2 = "ABCDABD";

        int[] next = kmpNext(str2);
        System.out.println("next=" + Arrays.toString(next));

        int index = kmpSearch(str1, str2, next);
        System.out.println("index=" + index);
    }

    /**
     * kmp搜索算法
     * @param str1  源字符串
     * @param str2  子串
     * @param next  部分匹配表，是子串对应的部分匹配表
     * @return
     */
    public static int kmpSearch(String str1, String str2, int[] next) {
        // 遍历
        for (int i = 0, j = 0; i < str1.length(); i++) {

            // KMP算法核心点
            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;
    }

    /**
     * 获取到一个字符串（子串）的部分匹配值 表
     * @param dest
     * @return
     */
    public static int[] kmpNext(String dest) {
        //创建一个next数组保存部分匹配值
        int[] next = new int[dest.length()];
        next[0] = 0;// 如果字符串是长度为1，部分匹配值就是0
        for (int i = 1, j = 0; i < dest.length(); i++) {
            // kmp算法的核心
            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;
    }
}

5. 贪心算法

5.1 基本介绍

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

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

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

思路分析

使用穷举法实现，列出每个可能的广播台的集合，这被称为幂集。假设总的有n个广播台，则广播台的组合总共有 2ⁿ- 1，假设每秒可以计算10个子集，如图：

使用贪心算法

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

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

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

5.4 代码实现

package com.lele.algorithm.greedy;

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

/**
 * author: hwl
 * date: 2020/12/10 21:31
 * version: 1.0.0
 * modified by:
 * description:
 */
public class GreedyAlgorithm {

    public static void main(String[] args) {

        // 创建广播电台，放入到map
        HashMap<String, HashSet<String>> broadcasts = new HashMap<>();
        // 将各个电台放入到broadcasts
        HashSet<String> hashSet1 = new HashSet<>();
        hashSet1.add("北京");
        hashSet1.add("上海");
        hashSet1.add("天津");

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

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

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

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

        // 加入到 map
        broadcasts.put("K1", hashSet1);
        broadcasts.put("K2", hashSet2);
        broadcasts.put("K3", hashSet3);
        broadcasts.put("K4", hashSet4);
        broadcasts.put("K5", hashSet5);

        // allAreas 存放所有的地区
        HashSet<String> allAreas = new HashSet<>();
        allAreas.add("北京");
        allAreas.add("上海");
        allAreas.add("天津");
        allAreas.add("广州");
        allAreas.add("深圳");
        allAreas.add("成都");
        allAreas.add("杭州");
        allAreas.add("大连");

        // 创建ArrayList,存放选择的电台集合
        ArrayList<String> selects = new ArrayList<String>();

        // 定义一个临时的集合，在遍历的过程中，存放遍历过程中的电台覆盖的地区和当前还没有覆盖的地区的交集
        HashSet<String> tempSet = new HashSet<>();

        // 定义一个maxKey，保存在一次遍历过程中，能够覆盖最大未覆盖的地区对应的电台的key
        // 如果maxKey不为null，则会加入到selects
        String maxKey = null;
        while(allAreas.size() != 0) {// 如果allAreas不为0,则表示还没有覆盖到所有的地区

            maxKey = null;

            // 遍历broadcasts,取出对应key
            for (String key : broadcasts.keySet()) {

                tempSet.clear();

                HashSet<String> areas = broadcasts.get(key);
                tempSet.addAll(areas);
                // 求出tempSet 和 allAreas 集合的交集
                tempSet.retainAll(allAreas);
                // 如果当前这个集合包含的未覆盖的地区的数量，比maxKey指向的集合为覆盖的地区还多
                // 需要重置maxKey
                if (tempSet.size() > 0 && (maxKey == null || tempSet.size() > broadcasts.get(maxKey).size())) {
                    maxKey = key;
                }
            }

            // maxKey != null
            if (maxKey != null) {
                selects.add(maxKey);
                // 将maxKey指向的广播电台覆盖的地区，从allAreas 去掉
                allAreas.removeAll(broadcasts.get(maxKey));
            }
        }
        System.out.println("得到的选择结果是：" + selects);// K1,K2,K3,K5
    }
}

6. 普里姆算法

6.1 应用场景-修路问题

在这里插入图片描述
胜利乡有7个村庄（A,B,C,D,E,F,G），现在需要修路把7个村庄连通，各个村庄的距离用边线表示（权），比如 A - B 距离 5 公里，问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短？

6.2 最小生成树

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

N个顶点，一定有N-1条边；
包含全部顶点；
N-1条边都在图中；
求最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法

6.3 普里姆算法

普里姆算法求最小生成树，也就是包含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；
重复步骤2，直到U与V相等，即所有顶点都被标记为访问过，此时D中有n-1条边；

6.4 代码实现

package com.lele.algorithm.prim;

import java.util.Arrays;

/**
 * author: hwl
 * date: 2020/12/13 8:36
 * version: 1.0.0
 * modified by:
 * description: 普里姆算法
 */
public class PrimAlgorithm {

    public static void main(String[] args) {

        // 测试图是否创建成功
        char[] data = new char[]{'A','B','C','D','E','F','G'};
        int verxs = data.length;
        // 邻接矩阵的关系使用二维数组表示,10000表示两个点不连通
        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对象
        MGraph mGraph = new MGraph(verxs);
        // 创建一个MinTree对象
        MinTree minTree = new MinTree();
        minTree.createGraph(mGraph, verxs, data, weight);
        // 输出
        minTree.showGraph(mGraph);

        // 测试普里姆算法
        minTree.prim(mGraph, 0);
    }
}

// 创建最小生成树 -> 村庄的图
class MinTree {

    /**
     * 创建图的邻接矩阵
     * @param graph 图对象
     * @param verxs 图的顶点个数
     * @param data 图的各个顶点的值
     * @param weight 图的邻接矩阵
     */
    public void createGraph(MGraph graph, int verxs, char data[], int[][] weight) {
        int i, j;
        for (i = 0; i < verxs; i++) { // 顶点
            graph.data[i] = data[i];
            for (j = 0; j < verxs; j++) {
                graph.weight[i][j] = weight[i][j];
            }
        }
    }

    /**
     * 显示图的邻接矩阵
     * @param graph
     */
    public void showGraph(MGraph graph) {
        for (int[] link : graph.weight) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * 编写prim算法，得到最小生成树
     * @param mGraph 图
     * @param v 表示从图的第几个顶点开始生成 'A' -> 0  'B' -> 1
     */
    public void prim(MGraph mGraph, int v) {
        // visited[] 标记结点（顶点）是否被访问过
        int[] visited = new int[mGraph.verxs];
//        // visited[]默认元素的值都是0，表示没有访问过
//        for (int i = 0; i < mGraph.verxs; i++) {
//            visited[i] = 0;
//        }

        // 把当前这个结点标记为已访问
        visited[v] = 1;
        // h1和h2记录两个顶点的下标
        int h1 = -1;
        int h2 = -1;
        // 将minWeight初始成一个大数，后面在遍历过程中，会被替换
        int minWeight = 10000;
        // 因为有mGraph.verxs顶点，普里姆算法结束后，有mGraph.verxs-1 条边
        for (int k = 1; k < mGraph.verxs; k++) {

            // 确定每一次生成的子图，和哪个结点的距离最近
            for (int i = 0; i < mGraph.verxs; i++) {// i结点表示被访问过的结点
                for (int j = 0; j < mGraph.verxs; j++) { // j结点表示还没有被访问过的结点
                    if (visited[i] == 1 && visited[j] == 0 && mGraph.weight[i][j] < minWeight) {
                        // 替换minWeight(寻找已经访问过的结点和未访问过的结点间的权值最小的边)
                        minWeight = mGraph.weight[i][j];
                        h1 = i;
                        h2 = j;
                    }
                }
            }
            // 找到一条边
            System.out.println("边<" + mGraph.data[h1] + "," + mGraph.data[h2] + "> 权值:" + minWeight);
            // 当前这个结点标记为已经访问
            visited[h2] = 1;
            // minWeight 重新设置为最大值10000
            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];
    }
}

7. 克鲁斯卡尔算法

7.1 公交站问题

在这里插入图片描述
某城市新增7个站点（A,B,C,D,E,F,G)，现在需要修路把7个站点联通，各个站点的距离用边线表示（权），比如 A-B 距离12公里，问：如何修路保证各个站点都能连通，并且总的修建公路总里程最短？

7.2 基本介绍

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

7.3 算法图解说明

以城市公交站问题来图解说明克鲁斯卡尔算法的原理和步骤：
在这里插入图片描述

7.4 算法分析

在这里插入图片描述

如何判断是否构成回路
在这里插入图片描述

7.5 代码实现

package com.lele.algorithm.kruskal;

import java.util.Arrays;

/**
 * author: hwl
 * date: 2020/12/13 14:29
 * version: 1.0.0
 * modified by:
 * description:
 */
public class KruskalCase {

    private int edgeNum; // 边的个数
    private char[] vertexs; // 顶点数量
    private int[][] matrix; // 邻接矩阵
    // 使用INF 表示两个顶点不能连通
    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 kruskalCase = new KruskalCase(vertexs, matrix);
        // 输出构建的
        kruskalCase.print();
        kruskalCase.kruskal();
    }

    // 构造器
    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 kruskal() {
        int index = 0;
        int[] ends = new int[edgeNum];// 用于保存“已有最小生成树” 中的每个顶点在最小生成树中的终点
        // 创建结果数组，保存最后的最小生成树
        EData[] rets = new EData[edgeNum];

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

        // 按照边的权值大小进行排序（从小到大）
        sortEdges(edges);

        // 遍历edges数组，将添加到最小生成树中时，判断准备加入的边是否形成了回路，如果没有，就加入rets，否则不能加入
        for (int i = 0; i < edgeNum; i++) {
            // 获取到第i条边的第一个顶点（起点）
            int p1 = getPosition(edges[i].start);// p1 = 4
            // 获取到第i条边的第2个顶点
            int p2 = getPosition(edges[i].end);// p2 = 5

            // 获取p1这个顶点在已有最小生成树中的终点
            int m = getEnd(ends, p1);// m = 4
            // 获取p2这个顶点在已有最小生成树中的终点
            int n = getEnd(ends, p2); // n= 5
            //是否构成回路
            if (m != n) {// 没有构成回路
                ends[m] = n;// 设置m在“已有最小生成树”中的终点 <E,F>[0,0,0,0,5,0,0,0,0,0,0,0]
                rets[index++] = edges[i];// 有一条边加入到rets数组
            }
        }
        // <E,F> <C,D><D,E><B,F><E,G><A,B>
        // 统计并打印 “最小生成树”，输出rets
        System.out.println("最小生成树为");
        for (int i = 0; i < index; i++) {
            System.out.println(rets[i]);
        }
    }

    /**
     * 打印邻接矩阵
     */
    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", matrix[i][j]);
            }
            // 换行
            System.out.println();
        }
    }

    /**
     * 功能：对边进行排序处理，冒泡排序
     * @param edges 边的集合
     */
    private void sortEdges(EData[] edges) {
        for(int i = 0; i < edges.length - 1; i++) {
            for (int j = 0; j < edges.length - 1 - i; j++) {
                if (edges[j].weight > edges[j+1].weight) {
                    EData tmp = edges[j];
                    edges[j] = edges[j+1];
                    edges[j+1] = tmp;
                }
            }
        }
    }

    /**
     *
     * @param ch 顶点的值，比如 'A','B'
     * @return 返回ch顶点对应的下标，如果找不到，返回-1
     */
    private int getPosition(char ch) {
        for (int i = 0; i < vertexs.length; i++) {
            if (vertexs[i] == ch) {// 找到
                return i;
            }
        }

        // 找不到，返回-1
        return -1;
    }

    /**
     * 获取图中边，放到EData[]数组中，后面我们需要遍历该数组
     * 通过邻接矩阵来获取
     * EData[] 形式 [['A','B',12],['B','F',7],....]
     * @return
     */
    private EData[] getEdges() {
        int index = 0;
        EData[] edges = new EData[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 EData(vertexs[i], vertexs[j], matrix[i][j]);
                }
            }
        }
        return edges;
    }

    /**
     * 获取下标为i的顶点的终点(),用于后面判断两个顶点的终点是否相同
     * @param ends 数组就是记录各个顶点对应的终点是哪个，ends数组是在遍历过程中，逐步形成
     * @param i 表示传入的顶点对应的下标
     * @return 下标为i的这个顶点对应的终点的下标
     */
    private int getEnd(int[] ends, int i) {
        while(ends[i] != 0) {
            i = ends[i];
        }
        return i;
    }
}


// 创建一个类EData，它的对象实例就表示一条边
class EData {
    char start;// 边的一个点
    char end; // 边的另一个点
    int weight;// 边的权值
    // 构造器
    public EData(char start, char end, int weight) {
        this.start = start;
        this.end = end;
        this.weight = weight;
    }

    // 重写toString
    public String toString() {
        return "EData[<" + start + ","+ end +">="+ weight +"]";
    }
}

8. 迪杰斯特拉算法

8.1 基本介绍

迪杰斯特拉算法是典型最短路径算法，用于计算一个结点到其他结点的最短路径。它的主要特点是以起始点为中心向外层层扩展（广度优先搜索思想），直到扩展到终点为止。

8.2 算法过程

在这里插入图片描述

8.3 最佳应用-最短路径

在这里插入图片描述

8.4 代码实现

package com.lele.algorithm.dijkstra;

import java.util.Arrays;

/**
 * author: hwl
 * date: 2020/12/14 21:52
 * version: 1.0.0
 * modified by:
 * description: 迪杰斯特拉算法
 */
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,N};
        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 graph = new Graph(vertex, matrix);
        // 测试
        graph.showGraph();

        // 测试 迪杰斯特拉算法
        graph.dsj(6);

        graph.showDijkstra();
    }

}

class Graph {
    private char[] vertex;//顶点数组
    private int[][] matrix;// 邻接矩阵
    private VisitedVertex vv; // 已经访问的顶点的集合

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

    /**
     * 显示结果
     */
    public void showDijkstra() {
        vv.show();
    }

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

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

        for (int j = 1; j < vertex.length; j++) {
            index = vv.updateArr();//选择并返回新的访问顶点
            update(index);// 更新index顶点到周围顶点的距离和前驱顶点
        }
    }

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

// 已访问的顶点集合
class VisitedVertex {
    // 记录各个顶点是否访问过1表示访问过，0表示未访问，会动态更新
    public int[] already_arr;
    // 每个下标对应的值为前一个顶点下标，会动态更新
    public int[] pre_visited;
    // 记录出发顶点到其他所有顶点的距离，比如G为出发点，就会记录G到其他顶点的距离，会动态更新，求的是最短距离就会存放到dis
    public int[] dis;

    /**
     * 构造器
     * @param length 表示顶点的个数
     * @param index 出发顶点对应的下标，比如G顶点，下标就是6
     */
    public VisitedVertex(int length, int index) {
        this.already_arr = new int[length];
        this.pre_visited = new int[length];
        this.dis = new int[length];

        // 初始化 dis数组
        Arrays.fill(dis,65535);
        this.already_arr[index] = 1;// 设置出发顶点被访问过
        this.dis[index] = 0;// 设置出发顶点的访问距离为0
    }

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

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

    /**
     * 更新pre这个顶点的前驱顶点为index顶点
     * @param pre
     * @param index
     */
    public void updatePre(int pre, int index) {
        pre_visited[pre] = index;
    }

    /**
     * 返回出发顶点到index顶点的距离
     * @param index
     * @return
     */
    public int getDis(int index) {
        return dis[index];
    }

    /**
     * 继续选择并返回新的访问顶点
     * @return
     */
    public int updateArr() {
        int min = 65535, 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("====================");
        // 输出already_arr
        for (int i : already_arr) {
            System.out.print(i + " ");
        }

        System.out.println();

        // 输出 pre_visited
        for (int i : pre_visited) {
            System.out.print(i + " ");
        }

        System.out.println();

        // 输出dis
        for (int i : dis) {
            System.out.print(i + " ");
        }

        System.out.println();
        // 为了好看
        char[] vertex = {'A','B','C','D','E','F','G'};
        int count = 0;
        for (int i : dis) {
            if (i != 65535) {
                System.out.print(vertex[count] + "(" + i + ")");
            } else {
                System.out.println("N ");
            }
            count++;
        }
        System.out.println();
    }
}

9. 弗洛伊德算法

9.1 弗洛伊德算法介绍

和Dijkstra算法一样，弗洛伊德算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。
弗洛伊德算法计算图中各个顶点之间的最短路径；迪杰斯特拉算法用于计算图中某一顶点到其他顶点的最短路径。
弗洛伊德算法 VS 迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每一个顶点到其他顶点的最短路径。

9.2 弗洛伊德算法图解

在这里插入图片描述

9.3 最佳应用-最短路径

在这里插入图片描述

9.4 代码实现

package com.lele.algorithm.floyd;

import java.util.Arrays;

/**
 * author: hwl
 * date: 2020/12/17 21:45
 * version: 1.0.0
 * modified by:
 * description: 弗洛伊德算法
 */
public class FloydAlgorithm {

    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[]{ 0, 5, 7, N, N, N, 2};
        matrix[1] = new int[]{ 5, 0, N, 9, N, N, 3};
        matrix[2] = new int[]{ 7, N, 0, N, 8, N, N};
        matrix[3] = new int[]{ N, 9, N, 0, N, 4, N};
        matrix[4] = new int[]{ N, N, 8, N, 0, 5, 4};
        matrix[5] = new int[]{ N, N, N, 4, 5, 0, 6};
        matrix[6] = new int[]{ 2, 3, N, N, 4, 6, 0};

        // 创建Graph对象
        Graph graph = new Graph(vertex.length, matrix, vertex);
        graph.floyd();
        graph.show();
    }
}

// 创建图
class Graph {
    private char[] vertex; // 存放顶点的数组
    private int[][] dis; // 保存，从各个顶点出发到其他顶点的距离，最后的结果，也是保留在该数组
    private int[][] pre; // 保存到达目标顶点的前驱顶点

    /**
     * 构造器
     * @param length 大小
     * @param matrix 领接矩阵
     * @param vertex 顶点数组
     */
    public Graph(int length, int[][] matrix, char[] vertex) {
        this.vertex = vertex;
        this.dis = matrix;
        this.pre = new int[length][length];
        // 对pre数组初始化， 存放的是前驱顶点的下标
        for (int i = 0; i < length; i++) {
            Arrays.fill(pre[i], i);
        }
    }

    /**
     * 显示pre数组和dis数组
     */
    public void show() {
        // 为了便于阅读
        char[] vertex = {'A','B','C','D','E','F','G'};
        for (int k = 0; k < dis.length; k++) {
            // 先将pre数组输出一行
            for (int i = 0; i < dis.length; i++) {
                System.out.print(vertex[pre[k][i]] + " ");
            }

            System.out.println();

            // 输出dis数组的一行数据
            for (int i = 0; i < dis.length; i++) {
                System.out.print("("+ vertex[k] + "到" + vertex[i] + "的最短路径是" + dis[k][i] + ") ");
            }

            System.out.println();
            System.out.println();
        }
    }

    public void floyd() {
        int len = 0;// 变量保存距离
        // 对中间结点遍历， k 就是中间顶点的下标
        for (int k = 0; k < dis.length; k++) {
            // 从i顶点开始出发 [A,B,C,D,E,F,G]
            for (int i = 0; i < dis.length; i++) {
                // 到达j顶点[A,B,C,D,E,F,G]
                for (int j = 0; j < dis.length; j++) {
                    len = dis[i][k] + dis[k][j];//求出从i顶点出发，经过k中间顶点，到达j顶点距离
                    if (len < dis[i][j]) { // 如果len小于dis[i][j]
                        dis[i][j] = len;// 更新距离
                        pre[i][j] = pre[k][j];// 更新前驱顶点
                    }
                }
            }
        }
    }
}

10. 马踏棋盘算法

10.1 基本介绍

马踏棋盘算法也称为骑士周游问题。将马随机放在国际象棋的 8X8 棋盘 Board[0~7][0~7] 的某个方格中，马按走棋规则（马走日字）进行移动，要求每个方格只进入一次，走遍棋盘上全部64个方格。

10.2 代码实现

在这里插入图片描述

package com.lele.algorithm.horse;

import java.awt.*;
import java.util.ArrayList;
import java.util.Comparator;

/**
 * author: hwl
 * date: 2020/12/20 8:36
 * version: 1.0.0
 * modified by:
 * description: 马走日（骑士周游问题）
 */
public class HorseChessboard {

    private static int X;// 棋盘的列数
    private static int Y;// 棋盘的行数
    private static boolean visited[];//标记棋盘的各个位置是否被访问
    private static boolean finished;// 标记棋盘上的所有位置是否都被访问, true:表示成功

    public static void main(String[] args) {
        System.out.println("骑士周游算法开始运行~~");
        // 测试骑士周游算法
        X = 8;
        Y = 8;
        int row = 1;// 马儿初始位置的行，从1开始编号
        int column = 1;// 马儿初始位置的列，从1开始编号

        // 创建棋盘
        int[][] chessboard = new int[X][Y];
        visited = new boolean[X * Y];// 初始值都是false

        // 测试 耗时
        long start = System.currentTimeMillis();
        traversalChessboard(chessboard, row - 1, column - 1, 1);
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");

        // 输出棋盘的最后情况
        for (int[] rows : chessboard) {
            for (int step : rows) {
                System.out.print(step + "\t");
            }
            System.out.println();
        }
    }

    /**
     * 骑士周游问题算法
     * @param chessboard 棋盘
     * @param row 马儿当前位置的行 从0开始
     * @param column 马儿当前位置的列 从0开始
     * @param step 第几步，初始位置就是第一步
     */
    public static void traversalChessboard(int[][] chessboard, int row, int column, int step) {
        chessboard[row][column] = step;
        visited[row * X + column] = true;// 标记该位置已经访问

        // 获取当前位置可以走的下一个位置的集合
        ArrayList<Point> ps = next(new Point(column, row));

        // 对ps进行排序，排序的规则是对ps的所有的Point对象的下一步的位置的数目，进行非递减排序
        sort(ps);

        // 遍历ps
        while(!ps.isEmpty()) {
            Point p = ps.remove(0);// 取出下一个可以走的位置
            // 判断该点是否已经访问过
            if (!visited[p.y * X + p.x]) {// 说明还没有访问过
                traversalChessboard(chessboard, p.y, p.x, step + 1);
            }
        }

        // 判断马儿是否完成了任务，使用 step 和应该走的步数比较，如果没有达到数量，则表示没有完成任务，将整个棋盘置0
        /**
         * 说明：
         * step < X * Y 成立的情况有两种：
         *  1.棋盘到目前位置，仍然没有走完
         *  2.棋盘处于一个回溯过程
         */
        if (step < X * Y && !finished) {
            chessboard[row][column] = 0;
            visited[row * X + column] = false;
        } else {
            finished = true;
        }
    }

    /**
     * 根据当前位置（Point对象），计算马儿还能走哪些位置（Point），并放入到一个集合中（ArrayList),最多有8个位置
     * @param curPoint
     * @return
     */
    public static ArrayList<Point> next(Point curPoint) {
        ArrayList<Point> ps = new ArrayList<>();

        Point p1 = new Point();
        // 表示 马儿可以走5这个位置
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }

        // 判断马儿是否可以走6这个位置
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        // 判断马儿是否可以走7这个位置
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        // 判断马儿是否可以走0这个位置
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        // 判断马儿是否可以走1这个位置
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        // 判断马儿是否可以走2这个位置
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        // 判断马儿是否可以走3这个位置
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        // 判断马儿是否可以走4这个位置
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        return ps;
    }

    /**
     * 根据当前这一步的所有的下一步的选择位置，进行非递减排序，减少回溯的次数
     * @param ps
     */
    public static void sort(ArrayList<Point> ps) {
        ps.sort(new Comparator<Point>() {
            @Override
            public int compare(Point o1, Point o2) {
                // 获取到 o1 的下一步的所有位置个数
                int count1 = next(o1).size();
                // 获取到 o2 的下一步的所有位置个数
                int count2 = next(o2).size();
                if (count1 < count2) {
                    return -1;
                } else if (count1 == count2) {
                    return 0;
                } else {
                    return 1;
                }
            }
        });
    }
}

红枫忆梦

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Java数据结构与算法（十三）：程序员常用的10种算法

1. 二分查找算法（非递归）1.1 基本介绍二分查找法只适用于从有序数列中进行查找（比如数字和字母等），将数列排序后再进行查找；二分查找法的运行时间为对数时间O(log2 n），即查找到需要的目标位置最多只需要log2 n步，假设从[0,99]的队列（100个数，即n=100）中寻到目标数30，则需要查找步数为 log2 100，即最多需要查找 7 次（2^6 < 100 < 2^7)1.2 代码实现package com.lele.algorithm.binarysearchno
复制链接

扫一扫