Java常用算法

原创于 2022-09-28 17:40:24 发布 · 223 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #开发语言

常用算法

二分查找非递归算法

public class BinarySearchNoRecur {
    public static void main(String[] args) {
        //测试
        int[] arr = {1, 3, 8, 10, 11, 67, 100};
        int index = binarySearch(arr, 8);
        System.out.println(((index != -1) ? "index=" + index : "未找到..."));
    }

    /**
     * 二分查找的非递归实现
     *
     * @param 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 - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
}

分治算法

Divide-and-Conquer

汉诺塔

public class HanoiTower {
    public static void main(String[] args) {
        hanoiTower(3, 'A', 'B', '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
            hanoiTower(num - 1, a, c, b);
            //2. 把最下边的盘A->C
            System.out.println("第" + num + "个盘从 " + a + "->" + c);
            //3. 把B塔的所有盘 从B->C
            hanoiTower(num - 1, b, a, c);
        }
    }
}

动态规划算法

0-1背包问题

public class KnapsackSelf03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入物品数量： ");
        int num = scanner.nextInt();
        int[] weight = new int[num + 1];
        int[] value = new int[num + 1];

        System.out.print("请输入背包容量: ");
        int capacity = scanner.nextInt();


        int[][] dp = new int[num + 1][capacity + 1];
        weight[0] = 0;
        for (int i = 1; i < num + 1; i++) {
            System.out.print("请输入第" + i + "件物品重量: ");
            weight[i] = scanner.nextInt();
        }
        value[0] = 0;
        for (int i = 1; i < num + 1; i++) {
            System.out.print("请输入第" + i + "件物品价值: ");
            value[i] = scanner.nextInt();
        }


        for (int i = 1; i < dp.length; i++) { //先遍历物品
            for (int j = 1; j < dp[i].length; j++) { //再遍历背包
                if (weight[i] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
                }
            }
        }

        for (int i = 0; i < num + 1; i++) {
            for (int j = 0; j < capacity + 1; j++) {
                System.out.print(dp[i][j] + "\t\t");
            }
            System.out.println();
        }
        System.out.println("背包内最大的物品价值总和为：" + dp[num][capacity]);// 有num个物品可选，且背包的容量为capacity的情况下，能装入背包的最大价值

        int[] item = new int[num + 1];
        int j = capacity;
        int i = num;
        while (i != 0) {
            if (dp[i][j] != dp[i-1][j]) {
                item[i] = i;
                j -= weight[i];
                i--;
            } else {
                i--;
            }
        }

        for (int w = item.length - 1; w >= 0; w--) {
            if (item[w] != 0) {
                System.out.print( "放入物品编号:" + item[w] + "\t");
            }
        }
    }
}

滚动数组

完全背包问题

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

        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int[] weight = new int[num + 1];
        int[] value = new int[num + 1];

        weight[0] = 0;
        for (int i = 1; i < num + 1; i++) {
            weight[i] = sc.nextInt();
        }
        value[0] = 0;
        for (int i = 1; i < num + 1; i++) {
            value[i] = sc.nextInt();
        }
        int capacity = sc.nextInt();//背包容量

        //动态规划表
        int[][] dp = new int[num + 1][capacity + 1];

        int[]temp = new int[num + 1];
        Arrays.fill(temp, 0);


        //动态规划表
        for (int i = 0; i < num + 1; i++) {
            for (int j = 0; j < capacity + 1; j++) {
                if (i == 0) {
                    dp[i][j] = 0;
                } else if (j == 0) {
                    dp[i][j] = 0;
                } else {
                    if (weight[i] > j) {
                        dp[i][j] = dp[i - 1][j];
                    } else {
                        for (int k = 0; k * weight[i] <= j; k++) {
                            dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - k * weight[i]] + k * value[i]);
                        }
                    }
                }
                System.out.println("最大价值=" + dp[i][j]);
            }
            System.out.println();
        }


        for (int i = 0; i < num + 1; i++) {
            for (int j = 0; j < capacity + 1; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

暴力匹配算法

public class ViolenceMatch {
    public static void main(String[] args) {
        //测试暴力匹配算法
        String str1 = "詹姆 詹姆詹姆 勒布朗詹姆姆斯詹姆斯";
        String str2 = "詹姆斯";
        int index = violenceMatch(str1, str2);
        if (index != -1) {
            System.out.println("index=" + index);
        } else {
            System.out.println("匹配失败...");
        }
    }

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

        int s1_len = s1.length;
        int s2_len = s2.length;

        int i = 0; //i指针指向s1
        int j = 0; //j指针指向s2
        while (i < s1_len && j < s2_len) { //保证匹配时，不越界
            if (s1[i] == s2[j]) {
                i++;
                j++;
            } else { //匹配失败
                i = i - j + 1; //回溯到上一次起始位置的下一个位置
                j = 0;
            }
        }
        //判断是否匹配成功
        if (j == s2_len) {
            return i - j;
        } else {
            return -1;
        }
    }
}

KMP算法

正月点灯笼

public class KmpAlgorithm02 {
    public static void main(String[] args) {
        String text = "ABABABCABAABABABAB";
        String find = "ABABCABAA";
        kmp_search(text, find);
    }

    public static int[] KmpNext(String find) {
        char[] chars = find.toCharArray();
        int[] next_table = new int[chars.length];
        next_table[0] = 0;
        int len = 0;
        int i = 1;
        while (i < chars.length) {
            if (chars[i] == chars[len]) {
                len++;
                next_table[i] = len;
                i++;
            } else {
                if (len > 0) {
                    len = next_table[len - 1];
                } else {
                    next_table[i] = 0;
                    i++;
                }
            }
        }
        return next_table;
    }

    //例如ababc假设失配位置是c,c左边的最大公共匹配长度为2，移动后利于kmpSearch方法的查找
    public static void move_next_table(int[] next_table) {
        for (int i = next_table.length - 1; i > 0; i--) {
            next_table[i] = next_table[i - 1];
        }
        next_table[0] = -1;
    }


    public static void kmp_search(String textStr, String findStr) {
        char[] text = textStr.toCharArray();
        char[] find = findStr.toCharArray();

        int[] next_table = KmpNext(findStr);
        move_next_table(next_table);

        int i = 0; //text的指针
        int j = 0; //find的指针

        while (i < text.length) {
            if (j == find.length - 1 && text[i] == find[j]) {
                System.out.printf("Found index at %d", i - j);
                j = next_table[j];
            }
            if (text[i] == find[j]) {
                i++;
                j++;
            } else {
                j = next_table[j];
                if (j == -1) {
                    i++;
                    j++;
                }
            }
        }
    }
}

解释为什么后移

例如ababc假设失配位置是c,c左边的最大公共匹配长度为2，移动后利于kmpSearch方法的查找

贪心算法

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

广播台	覆盖地区
K1	“杭州”, “北京”, “上海”, “天津”
K2	“广州”, “北京”, “上海”, “天津”
K3	“成都”, “武汉”, “杭州”
K4	“上海”, “天津”
K5	“广州”, “杭州”, “大连”

**注意：**因为tempSet存储的是当前广播所覆盖的地区和所有未覆盖地区的交集，而broadcasts存储的是某个广播对应的所有地区，试想一下，如果首先取得的一个广播所对应的与未覆盖地区的交集最小，并且该广播所覆盖的地区是最大的，那么后面的广播即使出现于所有未覆盖地区的交集比maxKey所覆盖的地区和所有未覆盖地区的交集大，由于maxKey广播所覆盖的地区是最大的，那么它不会满足上面的的贪心策略, 继而不会更新maxKey。

所以贪心策略核心如下：

//tempMaxKeySet是指一个maxKey临时的集合,在遍历过程中,maxKey覆盖的地区和当前还没有覆盖的地区的交集
//while循环里的比较时会用到
tempSet.size() > tempMaxKeySet.size()

源代码如下

import java.util.*;

public class GreedyAlgorithm {
    public static void main(String[] args) {
        //创建广播电台，放入到Map
        //利用hashmap键值对的特性，key表示广播站，value表示覆盖地区
        //hashset用于存储对象，不允许有重复的值
        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);

        //测试贪心算法
        List<String> selects = greedy(broadcasts);
        System.out.println(selects);
    }

    //存放所有地区
    public static List<String> greedy(HashMap<String, HashSet<String>> broadcasts) {
        //allAreas存放所有地区
        HashSet<String> allAreas = new HashSet<>();

        for (Map.Entry<String, HashSet<String>> entry : broadcasts.entrySet()) {
            HashSet<String> area = entry.getValue();
            Iterator<String> iterator = area.iterator();
            while (iterator.hasNext()) { //hasNext判断集合是否还有下个元素，如果是最后一个元素则返回false，不移动指针
                allAreas.add(iterator.next()); //把迭代器的指向移到下一个位置，同时返回下一个元素的引用
            }
        }

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

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

         /*
            定义一个maxKey,保存在一次遍历过程中,能够覆盖最大未覆盖的地区对应的电台的key
            如果maxKey不为null,则加入到selects中
         */
        String maxKey;
        //定义一个maxKey临时的集合,在遍历过程中,maxKey覆盖的地区和当前还没有覆盖的地区的交集
        HashSet<String> tempMaxKeySet = new HashSet<>();

        while (!allAreas.isEmpty()) { //如果allAreas不为空，表示还没有覆盖到所有地区
            //每次while循环都需要制空maxKey
            maxKey = null;

            //遍历broadcasts，取出对应的key
            for (String key : broadcasts.keySet()) {
                //每进行一次for
                tempSet.clear();
                //当前key所能覆盖的地区
                HashSet<String> area = broadcasts.get(key);
                tempSet.addAll(area);
                //求出tempSet 和 allAreas 集合的交集，交集会赋给tempSet
                tempSet.retainAll(allAreas);

                //tempSet.size() > maxKeyArea.size() 体现出贪心算法的特点，每次选择最优的
                if (tempSet.size() > 0 &&
                        (maxKey == null || tempSet.size() > tempMaxKeySet.size())) {
                    maxKey = key;

                    tempMaxKeySet = broadcasts.get(maxKey);
                    tempMaxKeySet.retainAll(allAreas);
                }
            }
            //maxKey != null, 就应该将maxKey 加入 selects
            if (maxKey != null) {
                selects.add(maxKey);
                //将maxKey指向的广播电台覆盖的地区从allAreas去除
                allAreas.removeAll(broadcasts.get(maxKey));
            }
        }
        return selects;
    }
}

普利姆算法

求最小生成树

（无向图）任意两个顶点都有路径相通 ——> 连通图
（有向图）任意两个顶点都相互连接 ——> 强连通图
连通图中，每个边都有权值 ——> 连通网
连通图的连通子图，包含图中所有的顶点，但只有构成一棵树的 n - 1 条边 ——> 生成树
（生成树如果再添加任意一条边一定会生成环）
在连通图中，所有边的代价最小的那棵树 ——> 最小生成树

import java.util.ArrayList;
import java.util.Arrays;

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 ={
                {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, 1);
    }
}

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

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

    //编写prim算法，得到最小生成树

    /**
     *
     * @param mGraph 图
     * @param v 表示图的第几个顶点开始生成
     */
    public void prim(MGraph mGraph, int v) {
        //集合存储已访问过的点
        ArrayList<Integer> visited = new ArrayList<>();
        //把当前顶点加入集合
        visited.add(v);
        //h1和h2记录两个顶点的下标
        int h1 = -1;
        int h2 = -1;
        int minWeight = 10000;//将minWeight初始成一个大数，后面在遍历过程中，会被替换


        //因为graph.vertexs顶点，普利姆算法结束后，会有graph.vertexs-1条边，因此从1开始遍历
        for (int k = 1; k < mGraph.verxs; k++) { //直到连同所有顶点为止

            //这是确定每一次生成的子图，哪个顶点和这次遍历的顶点的距离最近
            for (int i = 0; i < visited.size(); i++) { //i表示已被访问过的顶点
                for (int j = 0; j < mGraph.verxs; j++) { //j表示还没有访问过的顶点
                    if (! visited.contains(j)
                            && mGraph.weight[visited.get(i)][j] < minWeight) {
                        //替换minWeight = graph.weight[visited.get(i)][j];
                        minWeight = mGraph.weight[visited.get(i)][j];
                        h1 = visited.get(i);
                        h2 = j;
                    }
                }
            }
            //找到一条边最小
            System.out.println("边<" + mGraph.data[h1] + "," + mGraph.data[h2] + "> 权值:" + minWeight);
            //将当前这个顶点标记为已经访问
            visited.add(h2);
            //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 个站点(A, B, C, D, E, F, G) ，现在需要修路把 7 个站点连通
各个站点的距离用边线表示(权) ，比如 A – B 距离 12 公里
问：如何修路保证各个站点都能连通，并且总的修建公路总里程最短?

克鲁斯卡尔算法图解说明

第1步：将边<E,F>加入 R 中。

边<E,F>的权值最小，因此将它加入到最小生成树结果 R 中。

第2步：将边<C,D>加入 R 中。

上一步操作之后，边<C,D>的权值最小，因此将它加入到最小生成树结果 R 中。

第3步：将边<D,E>加入 R 中。

上一步操作之后，边<D,E>的权值最小，因此将它加入到最小生成树结果 R 中。

第4步：将边<B,F>加入 R 中。

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

第5步：将边<E,G>加入 R 中。

上一步操作之后，边<E,G>的权值最小，因此将它加入到最小生成树结果 R 中。

第6步：将边<A,B>加入 R 中。
上一步操作之后，边<F,G>的权值最小，但<F,G>会和已有的边构成回路；因此，跳过边<F,G>。同理，跳过边<B,C>。将边<A,B>加入到最小生成树结果 R 中。

此时，最小生成树构造完成！它包括的边依次是：<E,F> <C,D> <D,E> <B,F> <E,G> <A,B>。

克鲁斯卡尔算法分析

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

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

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

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

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

并查集

public class DisJoint_Set {
    public static void main(String[] args) {
        int vertices = 6;
        int[] parent = new int[vertices];
        int[] rank = new int[vertices];
        int[][] edges = new int[][]{
                {0, 1}, {1, 2}, {1, 3},
                {3, 4}, {2, 5}, {2, 4}
        };

        //初始化parent[]，如果parent[i] = i说明该节点的父节点是本身
        initialise(parent, vertices, rank);

        for (int[] edge : edges) {
            int x = edge[0];
            int y = edge[1];
            if (!union_vertices(x, y, parent, rank)) { //若没有合并成功说明有环
                System.out.println("Cycle detected!");
                break;
            }
            System.out.println("No found cycle");
        }
    }

    public static void initialise(int[] parent, int vertices, int[] rank) {
        for (int i = 0; i < vertices; i++) {
            parent[i] = i;
            rank[i] = 0;
        }
    }

    //寻找该节点的根节点
    //v 表示该节点的索引
    public static int find_root(int v, int[] parent) {
        //假设v就是父节点
        if (parent[v] == v) {
            return v;
        } else {
            parent[v] = find_root(parent[v], parent); //把每个双亲节点设置为根节点，路径压缩
            return parent[v];
        }
    }

    //true 成功合并
    //false 合并失败
    public static boolean union_vertices(int x, int y, int[] parent, int[] rank) {
        int x_root = find_root(x, parent);
        int y_root = find_root(y, parent);
        if (x_root == y_root) {
            return false;
        } else {
            if (rank[x_root] > rank[y_root]) {
                parent[y_root] = x;
            } else if (rank[x_root] < rank[y_root]) {
                parent[x_root] = y;
            } else {
                parent[y_root] = x;
                rank[x_root]++;
            }
            return true;
        }
    }
}

代码实现（Disjoint Set）

public class KruskalSelf02 {
    private int edgeNum;
    private char[] vertex;
    private int[][] matrix;
    private static final int INF = Integer.MAX_VALUE;
    private int[] parent;
    private int[] rank;

    public static void main(String[] args) {
        char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int[] parent = new int[vertex.length];
        int[] rank = new int[vertex.length];
        int[][] matrix = new int[][]{
                /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
                /*A*/{0, 12, INF, INF, INF, 16, 14},
                /*B*/{12, 0, 10, INF, INF, 7, INF},
                /*C*/{INF, 10, 0, 3, 5, 6, INF},
                /*D*/{INF, INF, 3, 0, 4, INF, INF},
                /*E*/{INF, INF, 5, 4, 0, 2, 8},
                /*F*/{16, 7, 6, INF, 2, 0, 9},
                /*G*/{14, INF, INF, INF, 8, 9, 0}
        };
        KruskalSelf02 kruskalSelf02 = new KruskalSelf02(vertex, matrix, parent, rank);
        int index = 0;
        int edgeNum = kruskalSelf02.getEdgeNum();
        Edge_Data[] result = new Edge_Data[edgeNum];
        Edge_Data[] edges = kruskalSelf02.getEdges();
        kruskalSelf02.sortEdge(edges);
        for (int i = 0; i < edgeNum; i++) {
            int v1 = kruskalSelf02.getPosition(edges[i].start);
            int v2 = kruskalSelf02.getPosition(edges[i].end);

            if (union_vertices(v1, v2, parent, rank)) {
                result[index++] = edges[i];
            }
        }
        System.out.println("最小生成树");
        for (int i = 0; i < index; i++) {
            System.out.println(result[i]);
        }
    }

    public KruskalSelf02(char[] vertex, int[][] matrix, int[] parent, int[] rank) {
        this.vertex = new char[vertex.length];
        this.vertex = vertex.clone();

        this.matrix = new int[vertex.length][vertex.length];
        for (int i = 0; i < vertex.length; i++) {
            this.matrix[i] = matrix[i].clone();
        }
        this.parent = new int[vertex.length];
        this.rank = new int[vertex.length];
        for (int i = 0; i < vertex.length; i++) {
            parent[i] = i;
            rank[i] = 0;
        }

    }

    public int getEdgeNum() {
        for (int i = 0; i < vertex.length; i++) {
            for (int j = i + 1; j < vertex.length; j++) {
                if (matrix[i][j] != INF) {
                    edgeNum++;
                }
            }
        }
        return edgeNum;
    }

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

    public void sortEdge(Edge_Data[] 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) {
                    Edge_Data temp = edges[j];
                    edges[j] = edges[j + 1];
                    edges[j + 1] = temp;
                }
            }
        }
    }

    public int getPosition(char ch) {
        for (int i = 0; i < vertex.length; i++) {
            if (vertex[i] == ch) {
                return i;
            }
        }
        return -1;
    }

    public Edge_Data[] getEdges() {
        int index = 0;
        Edge_Data[] edges = new Edge_Data[edgeNum];
        for (int i = 0; i < vertex.length; i++) {
            for (int j = i + 1; j < vertex.length; j++) {
                if (matrix[i][j] != INF) {
                    edges[index++] = new Edge_Data(vertex[i], vertex[j], matrix[i][j]);
                }
            }
        }
        return edges;
    }

    public static int find_root(int v, int[] parent) {
        if (parent[v] == v) {
            return v;
        } else {
            parent[v] = find_root(parent[v], parent);
            return parent[v];
        }
    }

    public static boolean union_vertices(int x, int y, int[] parent, int[] rank) {
        int x_root = find_root(x, parent);
        int y_root = find_root(y, parent);
        if (x_root == y_root) {
            return false;
        } else {
            if (rank[x_root] > rank[y_root]) {
                parent[y_root] = x_root;
            } else if (rank[x_root] < rank[y_root]) {
                parent[x_root] = y_root;
            } else {
                parent[y_root] = x_root;
                rank[x_root]++;
            }
            return true;
        }
    }

}

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

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

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

迪杰斯特拉算法

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

import java.util.Arrays;

public class DijkstraDemo {
    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;
        /*                    A  B  C  D  E  F  G*/
        matrix[0] = new int[]{N, 5, 7, N, N, N, 2};/*A*/
        matrix[1] = new int[]{5, N, N, 9, N, N, 3};/*B*/
        matrix[2] = new int[]{7, N, N, N, 8, N, N};/*C*/
        matrix[3] = new int[]{N, 9, N, N, N, 4, N};/*D*/
        matrix[4] = new int[]{N, N, 8, N, N, 5, 4};/*E*/
        matrix[5] = new int[]{N, N, N, 4, 5, N, 6};/*F*/
        matrix[6] = new int[]{2, 3, N, N, 4, 6, N};/*G*/
        //创建Graph对象
        Graph graph = new Graph(vertex, matrix);
        //测试邻接矩阵是否ok
        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 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顶点周围顶点的距离
        }
    }

    private void update(int index) {
        vv.already_arr[index] = 1;
        int len = 0;
        //根据遍历我们的邻接矩阵的 matrix[index]行
        for (int j = 0; j < matrix[index].length; j++) {
            len = vv.getDis(index) + matrix[index][j];
            // 如果j顶点没有被访问过，并且len小于出发顶点到j顶点的距离,就需要更新
            if (!vv.isVisited(j) && len < vv.getDis(j)) {
                vv.updatePre(j, index); //更新j顶点的前驱为index顶点
                vv.updateDis(j, len); //更新出发顶点到j顶点的距离
            }
        }
    }

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

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

    /**
     * 构造器
     *
     * @param vNum   表示顶点的个数
     * @param vIndex 出发顶点的下标，比如 G点，下标为 6
     */
    public VisitedVertex(int vNum, int vIndex) {
        this.already_arr = new int[vNum];
        this.pre_visited = new int[vNum];
        this.dis = new int[vNum];
        //初始化dis数组
        Arrays.fill(dis, 65535);
        this.dis[vIndex] = 0;// 设置出发顶点的访问距离为0
    }

    /**
     * 判断index下标对应的顶点是否访问过
     *
     * @param index
     * @return 如果访问过，就返回 true，否则返回 false
     */
    public boolean isVisited(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
     */
    public int getDis(int index) {
        return dis[index];
    }


    /**
     * 继续选择并返回新的访问顶点, 比如这里G访问完后，广度搜索选择距离最短的后继顶点作为新的访问顶点
     *
     * @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("==================================");
        //输出already_arr
        for (int i : already_arr) {
            System.out.print(i + "\t\t");
        }
        System.out.println();
        //输出pre_visited
        for (int i : pre_visited) {
            System.out.print(i + "\t\t");
        }
        System.out.println();
        //输出dis
        for (int i : dis) {
            System.out.print(i + "\t\t");
        }
    }
}

弗洛伊德算法

和Dijkstra算法一样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特弗洛伊德命名
弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径
迪杰斯特拉算法用于计算图中某一一个顶点到其他项点的最短路径。
弗洛伊德算法VS迪杰斯特拉算法:迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点的最短路径;弗洛伊德算法中每-一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每一个顶点到其他项点的最短路径。

代码实现

public class FloydSelf01 {
    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 = 100000;
        /*                    A  B  C  D  E  F  G*/
        matrix[0] = new int[]{N, 5, 7, N, N, N, 2};/*A*/
        matrix[1] = new int[]{5, 0, N, 9, N, N, 3};/*B*/
        matrix[2] = new int[]{7, N, 0, N, 8, N, N};/*C*/
        matrix[3] = new int[]{N, 9, N, 0, N, 4, N};/*D*/
        matrix[4] = new int[]{N, N, 8, N, 0, 5, 4};/*E*/
        matrix[5] = new int[]{N, N, N, 4, 5, 0, 6};/*F*/
        matrix[6] = new int[]{2, 3, N, N, 4, 6, 0};/*G*/

        int[][] path = new int[vertex.length][vertex.length];

        floyd(matrix, path, N);

    }

    public static void floyd(int[][] matrix, int[][] path, int N) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) {
                path[i][j] = -1;
            }
        }

        for (int m = 0; m < matrix.length; m++) {
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix.length; j++) {
                    if (matrix[i][m] + matrix[m][j] < matrix[i][j]) {
                        matrix[i][j] = matrix[i][m] + matrix[m][j];
                        path[i][j] = m; //记录经过哪个点到达
                    }
                }
            }
        }

        for (int i = 0; i < matrix.length; i++) {
            for (int j = i + 1; j < matrix.length; j++) {
                if (matrix[i][j] == N) {
                    System.out.println(i + "到" + j + "不可到达");
                } else {
                    System.out.print(i + "到" + j + "的最短路径长度为：" + matrix[i][j]);
                    System.out.print("  其最短路径：" + i + "->");
                    findPath(i, j, path);
                    System.out.println(j);
                }
            }
        }
    }

    public static void findPath(int i, int j, int[][] path) {
        int m = path[i][j];
        if (m == -1) {
            return;
        }
        findPath(i, m, path);
        System.out.print(m + "->");
        findPath(m, j, path);
    }
}

骑士周游问题

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

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) {
        //测试骑士周游算法是否正确
        X = 8;
        Y = 8;
        int row = 1; //初始位置的行
        int column = 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       是第几步，初始位置就是第1步
     */
    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(row, column));
        //对ps进行排序，排序规则就是对ps的所有Point对象的下一步的位置的数目，进行非递减排序
        sort(ps);
        //遍历ps
        while (!ps.isEmpty()) {
            Point p = ps.remove(0); //取出下一个可以走的位置
            //判断该点是否已访问
            if (!visited[p.x * X + p.y]) { //说明还没有访问过
                traversalChessBoard(chessboard, p.x, p.y, 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个位置
    public static ArrayList<Point> next(Point curPoint) {
        //创建ArrayList
        ArrayList<Point> ps = new ArrayList<>();
        //创建一个Point
        Point p1 = new Point();
        //判断马是否可以走5的位置
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走6的位置
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走7的位置
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走0的位置
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走1的位置
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走2的位置
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走3的位置
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y  -  1) >= 0) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走4的位置
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        return 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;
                }
            }
        });
    }
}

out.print(i + “\t\t”);
}
}
}


## 弗洛伊德算法

1. 和Dijkstra算法一 样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特弗洛伊德命名
2. 弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径
3. 迪杰斯特拉算法用于计算图中某一一个顶点到其他项点的最短路径。
4. 弗洛伊德算法VS迪杰斯特拉算法:迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点的最短路径;弗洛伊德算法中每-一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每一个顶点到其他项点的最短路径。

**代码实现**

```java
public class FloydSelf01 {
    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 = 100000;
        /*                    A  B  C  D  E  F  G*/
        matrix[0] = new int[]{N, 5, 7, N, N, N, 2};/*A*/
        matrix[1] = new int[]{5, 0, N, 9, N, N, 3};/*B*/
        matrix[2] = new int[]{7, N, 0, N, 8, N, N};/*C*/
        matrix[3] = new int[]{N, 9, N, 0, N, 4, N};/*D*/
        matrix[4] = new int[]{N, N, 8, N, 0, 5, 4};/*E*/
        matrix[5] = new int[]{N, N, N, 4, 5, 0, 6};/*F*/
        matrix[6] = new int[]{2, 3, N, N, 4, 6, 0};/*G*/

        int[][] path = new int[vertex.length][vertex.length];

        floyd(matrix, path, N);

    }

    public static void floyd(int[][] matrix, int[][] path, int N) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) {
                path[i][j] = -1;
            }
        }

        for (int m = 0; m < matrix.length; m++) {
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix.length; j++) {
                    if (matrix[i][m] + matrix[m][j] < matrix[i][j]) {
                        matrix[i][j] = matrix[i][m] + matrix[m][j];
                        path[i][j] = m; //记录经过哪个点到达
                    }
                }
            }
        }

        for (int i = 0; i < matrix.length; i++) {
            for (int j = i + 1; j < matrix.length; j++) {
                if (matrix[i][j] == N) {
                    System.out.println(i + "到" + j + "不可到达");
                } else {
                    System.out.print(i + "到" + j + "的最短路径长度为：" + matrix[i][j]);
                    System.out.print("  其最短路径：" + i + "->");
                    findPath(i, j, path);
                    System.out.println(j);
                }
            }
        }
    }

    public static void findPath(int i, int j, int[][] path) {
        int m = path[i][j];
        if (m == -1) {
            return;
        }
        findPath(i, m, path);
        System.out.print(m + "->");
        findPath(m, j, path);
    }
}

骑士周游问题

[外链图片转存中…(img-2Pf0VsI0-1664357828390)]

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

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) {
        //测试骑士周游算法是否正确
        X = 8;
        Y = 8;
        int row = 1; //初始位置的行
        int column = 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       是第几步，初始位置就是第1步
     */
    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(row, column));
        //对ps进行排序，排序规则就是对ps的所有Point对象的下一步的位置的数目，进行非递减排序
        sort(ps);
        //遍历ps
        while (!ps.isEmpty()) {
            Point p = ps.remove(0); //取出下一个可以走的位置
            //判断该点是否已访问
            if (!visited[p.x * X + p.y]) { //说明还没有访问过
                traversalChessBoard(chessboard, p.x, p.y, 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个位置
    public static ArrayList<Point> next(Point curPoint) {
        //创建ArrayList
        ArrayList<Point> ps = new ArrayList<>();
        //创建一个Point
        Point p1 = new Point();
        //判断马是否可以走5的位置
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走6的位置
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走7的位置
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走0的位置
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走1的位置
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走2的位置
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走3的位置
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y  -  1) >= 0) {
            ps.add(new Point(p1));
        }
        //判断马是否可以走4的位置
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        return 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;
                }
            }
        });
    }
}