常用的10种算法

一、二分查找算法（非递归）

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

package com.xudong.Algorithm;

public class BinarySearchNoRecursion {
    public static void main(String[] args) {
        int[] arr = {1,3,8,10,11,67,100};
        int index = binarySearch(arr,67);
        System.out.println("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) / 2;
            if (arr[mid] == target){
                return mid;
            }else if (arr[mid] > target){//向左查找
                right = mid - 1;
            }else {//向右查找
                left = mid + 1;
            }
        }
        return -1;
    }
}

分治算法

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

➢二分搜索、大整数乘法、棋盘覆盖、合并排序、快速排序、线性时间选择、最接近点对问题、循环赛日程表、汉诺塔

1.分治算法的基本步骤

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

2.分治算法设计模式

其中|P|表示问题P的规模; n0为一阈值，表示当问题P的规模不超过n0时，问题己容易直接解出，不必再继续分解。ADHOC(P)是该分治法中的基本子算法，用于直接解小规模的问题P。因此，当P的规模不超过n0时直接用算法ADHOC(P)求解。算法MERE(y1,y2,...,yk)是该分治法中的合并子算法，用于将P的子问题【P1 ,P2,...pk】的相应的解【y1,y2,...,yk】合并为P的解。

分治算法-汉诺塔

●汉诺塔：大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

汉诺塔游戏思路分析:

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

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

package com.xudong.Algorithm;

public class HanoiTower {
    public static void main(String[] args) {
        hanoiTower(5,'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..上面的盘
            //先把最上面的盘A->B,移动过程中使用到c
            hanoiTower(num - 1,a,c,b);
            //再把最下边的盘A->C
            System.out.println("第" + num + "个盘从 " + a + "->" + c);
            //最后把B塔的所有盘从B->C，移动过程中使用到a
            hanoiTower(num - 1,b,a,c);
        }
    }

}

动态规划算法

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

背包问题

●背包问题主要是指一个给定容量的背包、若千具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分01背包和完全背包(完全背包指的是:每种物品都有无限件可用)
●这里的问题属于01背包，即每个物品最多放一个。而无限背包可以转化为01背包。
有一个背包，容量为4磅，现有如下物品

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

思路分析

●算法的主要思想，利用动态规划来解决。每次遍历到的第i个物品，根据w[i]和v[i]来确定是否需要将该物品放入背包中。即对于给定的n个物品，设v[i]、w[i]分 别为第i个物品的价值和重量，C为背包的容量。再令v[i][i]表示在前i个物品中能够装入容量为j的背包中的最大价值。则我们有下面的结果:

➢v[i][0]=v[0][j]=0;

表示填入表第一行和第一列是0

➢当w[i]>j时: v[i][j]=v[i-1][i]

当准备加入新增的物品的容量大于当前背包的容量时，就直接使用上一个单元格的装入策略

➢当j>=w[i]时:v[i][j]=max{v[i-1][j],v[i]+v[i-1][j-W[i]]}

当准备加入的新增的商品的容量小于等于当前背包的容量时,装入的方式：
v[i-1][j]：就是上一个单元格的装入的最大值
v[i]：表示当前商品的价值
v[i-1][j-W[i]]：装入i-1 商品时，到剩余空间j-w[i]的最大值

package com.xudong.Algorithm;

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;//物品的个数

        //创建二维数组
        int[][] v = new int[n+1][m+1];
        //记录放入商品的情况
        int[][] path = 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];
                    }
                }
            }
        }

        //输出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
        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个物品放入背包
",i);
                j -= w[i -1];
            }
            i--;
        }
    }
}

KMP算法

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

package com.xudong.Algorithm;

import java.util.Arrays;

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搜索算法
    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[] 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;
    }
}

贪心算法

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

贪心算法应用

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

思路分析:

●目前并没有算法可以快速计算得到准备的值，使用贪婪算法，则可以得到非常接近的解，并且效率高。选择策略上，因为需要覆盖全部地区的最小集合:

➢遍历所有的广播电台,找到一个覆盖了最多未覆盖的地区的电台(此电台可能包含一些已覆盖的地区，但没有关系)
➢将这个电台加入到一个集合中(比如ArrayList),想办法把该电台覆盖的地区在下次比较时去掉。
➢重复第1步直到覆盖了全部的地区

package com.xudong.Algorithm;

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

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

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

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

        //保存遍历过程中电台覆盖的地区和当前没有覆盖地区的交集
        HashSet<String> tempSet = new HashSet<>();

        //定义maxKey，保存再一次遍历中，能够覆盖最大未覆盖地区对应电台的key
        String maxKey = null;
        while (allAreas.size() != 0){
            //每进行一次循环
            maxKey = null;
            //遍历broadcasts，取出对应的key
            for(String key : broadcasts.keySet()){
                //每次循环清空tempSet
                tempSet.clear();
                //当前这个key能够覆盖的地区
                HashSet<String> areas = broadcasts.get(key);
                tempSet.addAll(areas);
                //求出tempSet和allAreas集合的交集，并赋给tempSet
                tempSet.retainAll(allAreas);
                //如果当前集合包含的未覆盖地区的数量大于maxKey指向的集合地区还多，就需要重置maxKey
                if (tempSet.size() > 0 && (maxKey == null || tempSet.size() > broadcasts.get(maxKey).size())){
                    maxKey = key;
                }
            }
            //此时将maxKey加入selects
            if (maxKey != null){
                selects.add(maxKey);
                //将maxKey指向的广播电台覆盖的地区从allAreas去掉
                allAreas.removeAll(broadcasts.get(maxKey));
            }
        }
        System.out.println("得到的选择结果：" + selects);
    }
}

普里姆算法

最小生成树MST

●给定一个带权的无向连通图，选取一颗生成树，使树上所有边上权的总和最小，这就叫最小生成树，N个顶点，一定有N-1条边

普利姆算法介绍

●普利姆(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条边

package com.xudong.Algorithm;

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 vertexes = data.length;
        //邻接矩阵关系使用二维数组表示，使用变量保存大数，表示两点间不联通
        int m = 10000;
        int[][] weight = new int[][]{
                {m,5,7,m,m,m,2},
                {5,m,m,9,m,m,3},
                {7,m,m,m,8,m,m},
                {m,9,m,m,m,4,m},
                {m,m,8,m,m,5,4},
                {m,m,m,4,5,m,6},
                {2,3,m,m,4,6,m}
        };
        //创建MGraph对象
        MGraph graph = new MGraph(vertexes);
        //创建MinTree对象
        MinTree minTree = new MinTree();
        minTree.createGraph(graph,vertexes,data,weight);
        //输出
        minTree.showGraph(graph);

        minTree.prim(graph,0);
    }
}

//创建最小生成树
class MinTree{
    /**创建图的邻接矩阵
     * @param graph 图对象
     * @param vertexes 图对应顶点的个数
     * @param data 图的各个顶点的值
     * @param weight 图的邻接矩阵
     */
    public void createGraph(MGraph graph,int vertexes,char data[],int[][] weight){
        int i,j;
        for (i = 0; i < vertexes; i++) {
            graph.data[i] = data[i];
            for (j = 0; j < vertexes; 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算法，得到最小生成树,v是起点
    public void prim(MGraph graph,int v){
        //标记顶点是否被访问过,默认是0，表示没有访问过
        int visited[] = new int[graph.vertexes];
        //把当前节点标记为已访问
        visited[v] = 1;
        //h1和h2记录两个顶点的下标
        int h1 = -1;
        int h2 = -1;
        int minWeight = 10000;
        for (int k = 1; k < graph.vertexes; k++) {
            //确定每一次生成的子图和哪个节点的距离最近
            for (int i = 0; i < graph.vertexes; i++) {//i节点表示被访问过的节点
                for (int j = 0; j < graph.vertexes; j++) {//j节点表示还没有访问过的节点
                    if (visited[i] == 1 && visited[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);
            //将当前找到的节点标记为已经访问
            visited[h2] = 1;
            //重新设置minWeight
            minWeight = 10000;
        }
    }

}

class MGraph{
    int vertexes;//表示图的节点个数
    char[] data;//存放节点数据
    int[][] weight;//存放边，即邻接矩阵

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

克鲁斯卡尔算法

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

package com.xudong.Algorithm;

import java.util.Arrays;

public class KruskalCase {
    private int edgeNum;//边的个数
    private char[] vertexes;//顶点数组
    private int[][] matrix;//邻接矩阵
    //使用INF表示两点不能连桶
    private static final int INF = Integer.MAX_VALUE;

    public static void main(String[] args) {
        char[] vertexes = {'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(vertexes, matrix);
        //输出
        kruskalCase.print();

        kruskalCase.kruskal();
    }

    //构造器
    public KruskalCase(char[] vertexes,int[][] matrix){
        //初始化顶点和边的个数
        int vlen = vertexes.length;
        //用复制拷贝的方式初始化顶点
        this.vertexes = new char[vlen];
        for (int i = 0; i < vertexes.length; i++) {
            this.vertexes[i] = vertexes[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];
        //获取途中所有边的集合
        EData[] edges = getEdges();
        System.out.println("图的边的集合：" + Arrays.toString(edges) + "共" + edges.length + "条");
        //按照边的权值大小进行排序
        sortEdges(edges);
        //遍历edges数组，将边添加到最小生成树中时，判断准备加入的边是否形成了回路
        for (int i = 0; i < edgeNum; i++) {
            //获取第i条边的第1个顶点
            int p1 = getPosition(edges[i].start);
            //获取第i条边的第2个顶点
            int p2 = getPosition(edges[i].end);
            //判断p1,p2顶点在已有最小生成树中的终点
            int m = getEnd(ends,p1);
            int n = getEnd(ends,p2);
            //是否构成回路
            if (m != n){//没有构成回路
                ends[m] = n;//设置m在已有最小生成树中的终点
                rets[index++] = edges[i];
            }
        }
        //统计并打印最小生成树
        System.out.print("最小生成树为：");
        for (int i = 0; i < index; i++) {
            System.out.print(rets[i]);
        }
    }

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

    //对边进行冒泡排序处理
    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 顶点的值
     * @return 返回顶点对应的下标
     */
    private int getPosition(char ch){
        for (int i = 0; i < vertexes.length; i++) {
            if (vertexes[i] == ch){
                return i;
            }
        }
        return -1;
    }

    private EData[] getEdges(){
        int index = 0;
        EData[] edges = new EData[edgeNum];
        for (int i = 0; i < vertexes.length; i++) {
            for (int j = i + 1; j < vertexes.length; j++) {
                if (matrix[i][j] != INF){
                    edges[index++] = new EData(vertexes[i],vertexes[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;
    }

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

迪杰斯特拉算法

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

迪杰斯特拉(Dijkstra)算法过程

●设置出发顶点为v，顶点集合V{v1,2v.,v..}，v到V中各顶点的距离构成距离集合Dis, Dis{d1,d2,di...}，Dis集合记录着v到图中各顶点的距离(到自身可以看作0，v到vi距离对应为di)

1)从Dis中选 择值最小的di并移出Dis集合，同时移出V集合中对应的顶点vi,此时的v到vi即为最短路径

2. 更新Dis集合，更新规则为:比较v到V集合中顶点的距离值，与v通过vi到V集合中顶点的距离值，保留值较小的一个(同时也应该更新顶点的前驱节点为vi，表明是通过vi到达的)
3. 重复执行两步骤，直到最短路径顶点为目标顶点即可结束
   

package com.xudong.Algorithm;

import java.util.Arrays;

public class DijkstraAlgorithm {
    public static void main(String[] args) {
        char[] vertex = {'A','B','C','D','E','F','G'};
        int[][] matrix = new int[vertex.length][vertex.length];
        final int N = 65535;//表示不可连接
        matrix[0] = new int[]{N,5,7,N,N,N,2};
        matrix[1] = new int[]{5,N,N,9,N,N,2};
        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 showGraph(){
        for (int[] link : matrix){
            System.out.println(Arrays.toString(link));
        }
    }

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

    /**迪杰斯特拉算法实现
     * @param index 出发顶点对应的下标
     */
    public void dsj(int index){
        vv = new VisitedVertex(vertex.length, index);
        update(index);
        for (int j = 1; j < vertex.length; j++) {
            index = vv.updateArr();
            update(index);
        }
    }

    //更新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{
    //记录各个顶点是否访问过,0:未访问，1:已访问
    public int[] already_arr;
    //每个下标对应的值为前一个顶点的下标
    public int[] pre_visited;
    //记录出发顶点到其他所有顶点的距离，求出的最短距离会存放到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数组，初始点的访问距离为0，对于其他点为65535
        Arrays.fill(dis,65535);
        this.already_arr[index] = 1;//设置出发顶点被访问过
        this.dis[index] = 0;
    }

    /**判断index顶点是否被访问过
     * @param index 索引
     * @return 如果访问过，返回true，否则为false
     */
    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
     */
    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("------------------");
        for(int i : already_arr){
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i : pre_visited){
            System.out.print(i + " ");
        }
        System.out.println();
        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();
    }
}

弗洛伊德算法

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

弗洛伊德算法思想

●设置顶点vi到顶点vk的最短路径已知为Lik，顶点vk到vj的最短路径己知为Lkj，顶点vi到vj的路径为Lij，则vi到vj的最短路径为: min((ik+Lkj),Lij)， vk的取值为图中所有顶点，则可获得vi到vj的最短路径
●至于vi到vk的最短路径Lik或者vk到vj的最短路径Lkj，是以同样的方式获得

package com.xudong.Algorithm;

import java.util.Arrays;

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

        Graph1 graph1 = new Graph1(vertex.length, matrix, vertex);
        graph1.floyd();
        graph1.show();
    }
}

class Graph1{
    private char[] vertex;//存放顶点数组
    private int[][] dis;//保存从各个顶点出发到其他顶点的距离
    private int[][] pre;//保存到达目标顶点的前驱顶点

    /**构造器
     * @param length 大小
     * @param matrix 邻接矩阵
     * @param vertex 顶点数组
     */
    public Graph1(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();
            //将pre数组输出到一行
            for (int i = 0; i < dis.length; i++) {
                System.out.print("(" + vertex[k] + "到" + vertex[i] + "的最短路径是:" + dis[k][i] + ") ");
            }
            System.out.println();
        }
    }

    //弗洛伊德算法。容易理解，容易操作，但时间复杂度高O(n^3)。
    public void floyd(){
        int len = 0;//保存距离
        //对中间顶点遍历，k就是下标
        for (int k = 0; k < dis.length; k++) {
            //从i顶点出发
            for (int i = 0; i < dis.length; i++) {
                //到达j顶点
                for (int j = 0; j < dis.length; j++) {
                    len = dis[i][k] + dis[k][j];//从i顶点出发，经过k中间顶点，到的j顶点距离
                    if (len < dis[i][j]){
                        dis[i][j] = len;//更新距离
                        pre[i][j] = pre[k][j];//更新前驱节点
                    }
                }
            }
        }
    }
}

马踏棋盘算法（图的深度优先搜索DFS应用）

package com.xudong.Algorithm;

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;

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

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

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

    /**骑士周游问题算法
     * @param chessboard 棋盘
     * @param row 马当前位置的行
     * @param column 马当前位置的列
     * @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));
        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);
            }
        }
        //判断马是否完成任务,若没有完成，将棋盘置零
        if (step < X * Y && !finished){
            chessboard[row][column] = 0;
            visited[row * X + column] = false;
        }else {
            finished = true;
        }

    }

    public static ArrayList<Point> next(Point curPoint){
        //创建ArrayList
        ArrayList<Point> ps = new ArrayList<>();
        //创建一个Point
        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;
    }

    //根据当前这一步的所有的下一步的选择位置，进行非递减排序，减少回溯的次数
    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;
                }
            }
        });
    }
}