前言
我们从上篇文章开始给大家介绍日常生活中经典的算法，上篇文章给大家介绍了二分查找法、分治法以及其典型应用汉诺塔问题，文章最后介绍了动态规划算法以及背包问题。本文给大家介绍KMP算法、贪心算法、prim算法以及kruskal算法的详细内容。首先给大家介绍KMP算法。
一、KMP算法
1.1 字符串匹配问题
1、有一个字符串str1="我们要好好学习，努力工作，做一个有价值的人"和一个子串str2=“我们要好好学习”
2、现在我们需要判断str1是否包含str2，如果存在，就返回第一次出现的位置，如果没有，则返回-1。
1.2 暴力匹配法
如果用暴力匹配的思路，并假设现在str1匹配到i的位置，子串str2匹配到j的位置，则有：
- 1、如果当前字符串匹配成功，即
str1[i] == str2[j]，则i++，j++,继续匹配下一个字符- 2、如果失败，也就是
str1[i] != str2[j]，令i = i - (j-1), j= 0。相当于每次匹配失败时，i回溯，j被置为0- 3、用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量时间。
我们具体用java将其实现如下：
public class ViolenceMatch {
public static void main(String[] args) {
//测试暴力匹配算法
String str1 = "我们要好好学习，努力工作，做一个有价值的人";
String str2 = "做一个有价值的人";
int index = violenceMatch(str1, str2);
System.out.println("index=" + index);
}
// 暴力匹配算法实现
public static int violenceMatch(String str1, String str2) {
char[] s1 = str1.toCharArray();
char[] s2 = str2.toCharArray();
int s1Len = s1.length;
int s2Len = s2.length;
int i = 0; // i索引指向s1
int j = 0; // j索引指向s2
while (i < s1Len && j < s2Len) {
// 保证匹配时，不越界
if(s1[i] == s2[j]) {
//匹配ok
i++;
j++;
} else {
//没有匹配成功
//如果失配（即str1[i]! = str2[j]），令i = i - (j - 1)，j = 0。
i = i - (j - 1);
j = 0;
}
}
//判断是否匹配成功
if(j == s2Len) {
return i - j;
} else {
return -1;
}
}
}
具体的执行结果如下：
1.3 KMP算法介绍
KMP算法是一个解决模式串在文本串是否出现，如果出现过，最早出现的位置的经典算法。KMP算法其实是由Knuth-Morris-Pratt提出的。经常用与于一个文本串s内查找一个模式串p出现的位置。KMP算法其实就是利用之前判断过信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到前面匹配到的位置，很大程度上节省了匹配的时间。具体可以参考这篇文章，写的很好。本文这部分也是参考此篇文章。
1.4 KMP算法经典应用——字符串匹配问题
字符串匹配问题：
- 1、有一个字符串 str1 = "BBC ABCDAB ABCDABCDABCDE"和一个子串str2 = “ABCDABD”;
- 2、现在要判断str1是否包含有str2，如果存在，则返回第一个出现的位置，如果没有，则返回-1。
- 3、要求我们使用KMP算法完成判断，不能使用简单的暴力匹配算法。
具体的思路分析过程如下：
我们还是以之前的字符串来说明整个匹配过程。
- 1、首先，用str1的第一个字符串和str2的第一个字符串去比较，不符合，关键词向后移动一位。具体如下：
- 2、重复上一步，不符合还是往后移动。
- 3、一直重复，直到str1有一个字符与str2的第一个字符符合为止。
- 4、接着比较字符串和搜索词的下一个字符，还是符合。
- 5、遇到str1有一个字符与str2相对应的字符不符合。
- 6、这个时候，想到的是继续遍历str1的下一个字符，重复第一步。其实，这是不明智的，因为我们之前比较过了，没不要在做重复的工作，因此，我们只需要从不匹配的开始比较即可，这就是KMP最为核心的思想，这就大大提高了匹配的效率。
- 7、我们已经知道D是不匹配的，前面六个字符“ABCDAB”是匹配的，因此，我们需要将子串向后移动4位。因此当空格与C不匹配时，搜索词还要继续往后移，这时，已匹配的字符数为2，对应的匹配值为0.所以，我们只需要向后移动2.
- 8、因为空格与字符串不匹配，因此，继续向后移动。
- 9、逐位比较，知道发现C与D不匹配，于是，我们继续向后移动4位。
- 10、逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。
以上就是KMP算法的全部过程。接下来我们通过java将其过程实现：
import java.util.Arrays;
public class KMPAlgorithm {
public static void main(String[] args) {
String str1 = "BBC ABCDAB ABCDABCDABDE";
String str2 = "ABCDABD";
//String str2 = "BBC";
int[] next = kmpNext("ABCDABD"); //[0, 1, 2, 0]
System.out.println("next=" + Arrays.toString(next));
int index = kmpSearch(str1, str2, next);
System.out.println("index=" + index); // 15了
}
//写出我们的kmp搜索算法
/**
*
* @param str1 源字符串
* @param str2 子串
* @param next 部分匹配表, 是子串对应的部分匹配表
* @return 如果是-1就是没有匹配到，否则返回第一个匹配的位置
*/
public static int kmpSearch(String str1, String str2, int[] next) {
//遍历
for(int i = 0, j = 0; i < str1.length(); i++) {
//需要处理 str1.charAt(i) ！= str2.charAt(j), 去调整j的大小
//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()) {
//找到了 // j = 3 i
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++) {
//当dest.charAt(i) != dest.charAt(j) ，我们需要从next[j-1]获取新的j
//直到我们发现 有 dest.charAt(i) == dest.charAt(j)成立才退出
//这时kmp算法的核心点
while(j > 0 && dest.charAt(i) != dest.charAt(j)) {
j = next[j-1];
}
//当dest.charAt(i) == dest.charAt(j) 满足时，部分匹配值就是+1
if(dest.charAt(i) == dest.charAt(j)) {
j++;
}
next[i] = j;
}
return next;
}
}
我们求得next数组以及匹配结果如下图所示：
二、贪心算法
2.1 集合覆盖问题
假设存在下面需要付费的广播台以及广播台信号可以覆盖地区。如何选择最少的广播台，让所有地区都可以接收到信号。具体如下：
2.2 贪心算法介绍
贪心算法是指在对问题进行求解时，在每一步选择中都采取最好或者最优的选择，从而希望能够导致结果是最好挥着最优的算法。
需要我们注意的是：贪心算法所得到的的结果不一定是最优的结果，但是都是相对近似最优解的结果。
我们还是针对集合覆盖问题做一个简单的思路分析：
如何能找出覆盖所有地区的广播台的集合呢，使用穷举法实现，列举出每个可能广播台的集合，这被称为幂集。假设总的有n个广播台，则广播台的组合总共有2n-1个，假设每秒可以计算10个子集，具体如图所示：
但是，其实使用贪心算法效率更高。目前并没有算法可以快速计算得到准备的值，使用贪婪算法，则可以得到非常接近的解，并且效率高。选择策略上，因为需要覆盖全部地区的最小集合。遍历所有的广播电台，找到一个覆盖了最多覆盖的地区的电台。我们可以将这个电台加入到一个集合中，想办法把该电台覆盖的地区在下次比较时去掉。具体分析的图解如下所示：
具体用java将上面的思路实现如下：
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<String, HashSet<String>>();
//将各个电台放入到broadcasts
HashSet<String> hashSet1 = new HashSet<String>();
hashSet1.add("北京");
hashSet1.add("上海");
hashSet1.add("天津");
HashSet<String> hashSet2 = new HashSet<String>();
hashSet2.add("广州");
hashSet2.add("北京");
hashSet2.add("深圳");
HashSet<String> hashSet3 = new HashSet<String>();
hashSet3.add("成都");
hashSet3.add("上海");
hashSet3.add("杭州");
HashSet<String> hashSet4 = new HashSet<String>();
hashSet4.add("上海");
hashSet4.add("天津");
HashSet<String> hashSet5 = new HashSet<String>();
hashSet5.add("杭州");
hashSet5.add("大连");
//加入到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<String>();
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<String>();
//定义给maxKey ， 保存在一次遍历过程中，能够覆盖最大未覆盖的地区对应的电台的key
//如果maxKey 不为null , 则会加入到 selects
String maxKey = null;
while(allAreas.size() != 0) {
// 如果allAreas 不为0, 则表示还没有覆盖到所有的地区
//每进行一次while,需要
maxKey = null;
//遍历 broadcasts, 取出对应key
for(String key : broadcasts.keySet()) {
//每进行一次for
tempSet.clear();
//当前这个key能够覆盖的地区
HashSet<String> areas = broadcasts.get(key);
tempSet.addAll(areas);
//求出tempSet 和 allAreas 集合的交集, 交集会赋给 tempSet
tempSet.retainAll(allAreas);
//如果当前这个集合包含的未覆盖地区的数量，比maxKey指向的集合地区还多
//就需要重置maxKey
// tempSet.size() >broadcasts.get(maxKey).size()) 体现出贪心算法的特点,每次都选择最优的
if(tempSet.size() > 0 &&
(maxKey == null || tempSet.size() >broadcasts.get(maxKey).size())){
maxKey = key;
}
}
//maxKey != null, 就应该将maxKey 加入selects
if(maxKey != null) {
selects.add(maxKey);
//将maxKey指向的广播电台覆盖的地区，从 allAreas 去掉
allAreas.removeAll(broadcasts.get(maxKey));
}
}
System.out.println("得到的选择结果是" + selects);//[K1,K2,K3,K5]
}
}
具体的执行效果如下图所示：
当然，我们在用贪心算法的时候，需要注意以下的细节：
贪心算法所得到的结果不一定是最优的结果(有时会是最优解)，但是都是相对接近最优解的结果。例如我们刚才的案例中，我们选出的是K1,K2,K3,K5，符合覆盖了全部的地区。但是我们发现K2,K3K4,K5也可以覆盖全部地区，如果K2的使用成本低于K1，那么我们刚才给出的条件虽然是符合要求的，但不是最优的。
三、prim算法
3.1 、修路问题
看一个应用场景和问题：
有胜利乡有7个村庄，分别为A,B,C,D,E,F,G，现在需要修路把这7个村庄连通。各个村庄的距离用权来表示，比如A-B之间距离为5，那么如何修路保证各个村庄都是连通的，并且总的修建公路总里程最短？其实，我们将图中的这10条边连接即可，但是总里程数不是最小。因此，正确的思路应该是尽可能的选择少的路线，并且每条路线最小，这样才能够保证总里程数最小。
3.2 最小生成树
修路问题本质上就是最小生成树，先介绍一下最小生成树。
我们给定一个带权的无向连通图，如何选择一颗生成树，使树上的所有边的权值加起来最小，这就是最小生成树。最小生成树具备以下的性质：
- 1、N个顶点至少有N-1条边
- 2、包含全部顶点
- 3、N-1条边都在图中
我们求最小生成树的算法主要是prim算法和kruskal算法。具体最小生成树过程如下：
3.3 prim算法介绍
prim算法求最小生成树，也就是在包含n个顶点的连通图中，找出只有(n-1)条边包含所有N个顶点的连通子图，也就是所谓的极小连通子图。prim算法如下：
- 1、设G=(V,E)是连通网，T=(U,D)是最小生成树，U，V是顶点集合，E,D是边的集合
- 2、若从顶点u开始构造做小生成树，则从集合V中取出顶点u放入集合U中，标记顶点v的
visited[u]=1- 3、若集合U中顶点ui与集合V-U中的顶点vj之间存在边，则寻找这条边中权值最小的边，但不能构成回路，将顶点vj加入到集合U中，将边(ui,vj)加入到集合D中，标记顶点v的
visited[vj]=1- 4、重复步骤2，直到u与v相等，即所有的顶点都被标记为访问过，此时D中有
n-1条边。
为了更好的理解上面的思路，我们通过一个案例具体说明：还是开始修路用到的图，我们将其用prim算法进行如下的构造生成树：
- 1、从 < A> 顶点开始处理 ======> <A,G>
2 A-C [7] A-G[2] A-B[5] =>- 2、<A,G> 开始 , 将A 和 G 顶点和他们相邻的还没有访问的顶点进行处理 =》<A,G,B> A-C[7] A-B[5] G-B[3] G-E[4] G-F[6]
- 3、<A,G,B> 开始，将A,G,B 顶点 和他们相邻的还没有访问的顶点进行处理=><A,G,B,E> A-C[7] G-E[4] G-F[6] B-D[9] …
- 4、{A,G,B,E}->F//第4次大循环 ， 对应 边<E,F> 权值：5
- 5、{A,G,B,E,F}->D//第5次大循环 ， 对应 边<F,D> 权值：4
- 6、 {A,G,B,E,F,D}->C//第6次大循环 ， 对应 边<A,C> 权值：7
最后的结果为： <A,G,B,E,F,D,C>
我们通过用prim算法进行构造最小生成树，具体用java实现如下：
import java.util.Arrays;
public class PrimAlgorithm {
public static void main(String[] args) {
//测试看看图是否创建ok
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 graph = new MGraph(verxs);
//创建一个MinTree对象
MinTree minTree = new MinTree();
minTree.createGraph(graph, verxs, data, weight);
//输出
minTree.showGraph(graph);
//测试普利姆算法
minTree.prim(graph, 1);//
}
}
//创建最小生成树->村庄的图
class MinTree {
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];
}
}
}
//显示图的邻接矩阵
public void showGraph(MGraph graph) {
for(int[] link: graph.weight) {
System.out.println(Arrays.toString(link));
}
}
public void prim(MGraph graph, int v) {
//visited[] 标记结点(顶点)是否被访问过
int visited[] = new int[graph.verxs];
//把当前这个结点标记为已访问
visited[v] = 1;
//h1 和 h2 记录两个顶点的下标
int h1 = -1;
int h2 = -1;
int minWeight = 10000; //将 minWeight 初始成一个大数，后面在遍历过程中，会被替换
for(int k = 1; k < graph.verxs; k++) {
//因为有 graph.verxs顶点，普利姆算法结束后，有 graph.verxs-1边
//这个是确定每一次生成的子图 ，和哪个结点的距离最近
for(int i = 0; i < graph.verxs; i++) {
// i结点表示被访问过的结点
for(int j = 0; j< graph.verxs;j++) {
//j结点表示还没有访问过的结点
if(visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < minWeight) {
//替换minWeight(寻找已经访问过的结点和未访问过的结点间的权值最小的边)
minWeight = graph.weight[i][j];
h1 = i;
h2 = j;
}
}
}
//找到一条边是最小
System.out.println("边<" + graph.data[h1] + "," + graph.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];
}
}
执行的结果如下：
四、kruskal算法
4.1 应用场景——问题
首先看下面的一个场景以及问题：
我们有以下的需求需要我们去解决：
- 1、某城市新增7个站点(A,B，C,D,E,F,G)，现在需要修路把7个站点连通
- 2、各个站点的距离用边线表示权，比如图中的A-B的距离为12公里
- 3、这里有一个问题：如何修路保证各个站点都能连通，并且总的修建公路总里程最短？
kruskal算法与前面的prim算法类似，也是用来求加权连通图的最小生成树的算法。其基本思想为：按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路。具体做法如下：
首先构造一个只含n个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止。
4.2 kruskal算法图解说明
我们以城市公交站问题来图解说明kruskal算法的原理和步骤，我们以前面提到的城市公交问题来说明kruskal算法的原理和步骤。
在含有n个顶点的连通图中选择n-1条边，构成一颗极小的连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树。
我们对于上图G4所示的连通网可以有多颗权值总和不相同的生成树。
接下来，我们以上图中G4为例，来对kruskal算法构造最小生成树的过程进行演示：
- 1、选取边<E,F>
- 2、选取边<C,D>
- 3、选取边<D,E>
- 4、选取边< B，F>
- 5、选取边<E,G>
- 6、选取边<A,B>
4.3 kruskal算法分析
根据前面介绍的kruskal算法的基本思想和做法，我们可以看出：kruskal算法重点需要解决一下的两个问题：
- 1、对图的所有边按照权值大小进行排序
- 2、将边添加到最小生成树中，怎么判断是否形成回路
针对问题一，我们只需对边的权值进行排序即可。对于问题二的处理方式是：记录顶点在“最小生成树”中的终点，顶点的终点是“在最小生成树中与它连通的最大顶点”。然后每次需要将一条边添加到最小生成树时，判断该边的两个顶点是否会重合，重合的话就会构成回路。这里的终点是将所有的顶点按照从小到大的顺序排列好之后；某个顶点的终点就是“与它连通的最大顶点”。因此，我们加入的边的两个顶点不能都指向同一个终点，否则将构成回路。这就是回路判断的方法。接下来，我们通过java将其城市交通问题进行实现：
import java.util.Arrays;
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[][] = {
/*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}};
//大家可以在去测试其它的邻接矩阵，结果都可以得到最小生成树.
//创建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();//换行
}
}
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;
}
}
}
}
private int getPosition(char ch) {
for(int i = 0; i < vertexs.length; i++) {
if(vertexs[i] == ch) {
//找到
return i;
}
}
//找不到,返回-1
return -1;
}
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;
}
private int getEnd(int[] ends, int i) {
// i = 4 [0,0,0,0,5,0,0,0,0,0,0,0]
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, 便于输出边信息
@Override
public String toString() {
return "EData [<" + start + ", " + end + ">= " + weight + "]";
}
}
执行的结果如图所示：
总结
我们从上篇文章开始给大家介绍日常生活中经典的算法，上篇文章给大家介绍了二分查找法、分治法以及其典型应用汉诺塔问题，文章最后介绍了动态规划算法以及背包问题。本文给大家介绍了KMP算法、贪心算法、prim算法以及kruskal算法的详细内容。其中分别通过一些经典的案例加以说明进行实现。其实数据结构与算法是特别重要的，在编程中有至关重要的地位，因此，需要我们特别的掌握。生命不息，奋斗不止，我们每天努力，好好学习，不断提高自己的能力，相信自己一定会学有所获。加油！！！