网课指路:【尚硅谷】数据结构与算法（Java数据结构与算法）_哔哩哔哩_bilibili
1.二分查找算法
二分查找算法(非递归)介绍
①二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找
②二分查找法的运行时间为对数时间O(㏒₂n) ，即查找到需要的目标位置最多只需要㏒₂n步，假设从[0,99]的队列(100个数，即n=100)中寻到目标数30，则需要查找步数为㏒₂100 , 即最多需要查找7次( 2^6 < 100 < 2^7)
代码:
public class Demo {
public static void main(String[] args) {
int []arr = {1,3,4,6,7,9};
System.out.println(binarySearch(arr, 7));
}
//二分查找 非递归
public static int binarySearch(int []arr,int target){
int left = 0;
int right = arr.length-1;
while (left<=right){
int mid = (right-left)/2+left;
if (target==arr[mid]){
return mid;
}else if(target>arr[mid]){
left=mid+1;
}else {
right=mid-1;
}
}
return -1;
}
}
递归二分查找复习:
·思路
①首先确定该数组的中间下标 mid=(left+right)/2
②然后让需要查找的数findValue和arr[mid]比较
·findValue>arr[mid] 说明你要查找的数在mid右边 因此需要递归的向右查找
·findValue<arr[mid] 说明你要查找的数在mid左边 因此需要递归的向左查找
·findValue=arr[mid] 说明找到了 返回
③找到了 就结束递归 若递归完整个数组仍然没找到findValue 也需要结束递归
即:left>right就需要退出
代码:
public class BinarySearch {
public static void main(String[] args) {
int []arr = {1,3,4,7,8,9,22};
int left = 0;
int right = arr.length-1;
int findValue=3;
int i = binarySearch(arr, left, right, findValue);
System.out.println(i);
}
private static int binarySearch(int[] arr, int left, int right, int findValue) {
int mid = (left + right) / 2;
int midValue = arr[mid];
if (left>right)
return -1;
if (findValue > midValue) {
return binarySearch(arr, mid + 1, right, findValue);
} else if (findValue < midValue) {
return binarySearch(arr, 0, mid - 1, findValue);
} else {
return mid;
}
}
}
分治算法
分治算法介绍
分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……
分治算法可以求解的一些经典问题
二分搜索
大整数乘法
棋盘覆盖
合并排序
快速排序
线性时间选择
最接近点对问题
循环赛日程表
汉诺塔
分治算法的基本步骤
分治法在每一层递归上都有三个步骤：
①分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
②解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
③合并：将各个子问题的解合并为原问题的解。
分治算法最佳实践-汉诺塔
汉诺塔的传说 汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
假如每秒钟一次，共需多长时间呢？移完这些金片需要5845.54亿年以上，太阳系的预期寿命据说也就是数百亿年。真的过了5845.54亿年，地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭。
汉诺塔游戏的演示和思路分析:
如果是有一个盘， A->C
如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的盘 2.上面的盘
①先把 最上面的盘 A->B
②把最下边的盘 A->C
③把B塔的所有盘 从 B->C
代码:
public class Demo {
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.先把最上面的所有盘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);
}
}
}
动态规划算法
动态规划算法介绍
1.动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法
2.动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
3.与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 ( 即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )
4.动态规划可以通过填表的方式来逐步推进，得到最优解.
应用场景-背包问题
背包问题：有一个背包，容量为4磅 ， 现有如下物品
| 物品 | 重量 | 价格 |
|---|---|---|
| 吉他(G) | 1 | 1500 |
| 音响(S) | 4 | 3000 |
| 电脑(L) | 3 | 2000 |
1)要求达到的目标为装入的背包的总价值最大 并且重量不超出
2)要求装入的物品不能重复
解决类似的问题 可以分解成一个个的小问题进行解决 假设存在背包容量大小分为1,2,3,4的各种容量的背包(分配容量的规则为最小重量的整数倍)
eg:
背包填表过程
| 物品 | 0磅 | 1磅 | 2磅 | 3磅 | 4磅 |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | |
| 吉他(G) | 0 | 1500(G) | 1500(G) | 1500(G) | 1500(G) |
| 音响(S) | 0 | 1500(G) | 1500(G) | 1500(G) | 3000(S) |
| 电脑(L) | 0 | 1500(G) | 1500(G) | 2000(L) | 2000(L)+ 1500(G) |
tips:①只有吉他 这时 不管背包容量多大 只能放一个吉他(G)
②有吉他和音响
③都有
3)思路分析和图解
背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分01背包和完全背包(完全背包指的是：每种物品都有无限件可用)
这里的问题属于01背包，即每个物品最多放一个。而无限背包可以转化为01背包。
(1) v[i][0]=v[0][j]=0; //表示 填入表 第一行和第一列是0
(2) 当w[i]> j 时：v[i][j]=v[i-1][j] // 当准备加入新增的商品的容量大于当前背包的容量时，就直接使用上一个单元格的装入策略
(3) 当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]的最大值 当
即:j>=w[i]时： v[i][j]=max{v[i-1][j], v[i]+v[i-1][j-w[i]]} :
代码:
import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
int []w = {1,4,3};//物品的重量
int []price = {1500,3000,2000};//物品的价值 这里price[i]
int m = 4;//背包的容量
int n = price.length;//物品的个数
//为了记录放入商品的情况 定义一个二二数组
int [][]path = new int[n+1][m+1];
//二维数组
//v[i][j] 表示前i个物品中能够装入容量为j的背包中的最大价值
int [][]v = new int[n+1][m+1];
//初始化第一行和第一列为0 这里可以不用处理 因为默认是0
for (int i = 0; i < v.length; i++) {
for (int j = 0; j <v[0].length ; j++) {
if(i==0||j==0){
v[i][j]=0;
}else {
//公式
if(w[i-1]>j){//因为w的下标是0，1，2 而填表的时候第0列是0 第一列开始才是物品 所以需要减一
v[i][j]=v[i-1][j];
}else if(w[i-1]<=j){
/*
v[i][j]=Math.max(v[i-1][j],price[i-1]+v[i-1][j-w[i-1]]);
为了详细记录物品存放的情况 上述这个不能再用了 需使用if-else
*/
if(v[i-1][j]<price[i-1]+v[i-1][j-w[i-1]]){
v[i][j]=price[i-1]+v[i-1][j-w[i-1]];
path[i][j]=1;
}else {
v[i][j]=v[i-1][j];
}
}
}
}
}
for (int i = 0; i < v.length; i++) {
for (int j = 0; j < v[0].length; j++) {
System.out.print(v[i][j] + " ");
}
System.out.println();
}
int i = path.length-1;//行的最大下标
int j = path[0].length-1;//列的最大下标
while (i>0&&j>0){
if(path[i][j]==1){
System.out.println("把第" + i + "个商品放入背包");
j-=w[i-1];
}
i--;
}
}
}
KMP算法
应用场景-字符串匹配问题
字符串匹配问题：
1.有一个字符串 str1= ""硅硅谷 尚硅谷你尚硅 尚硅谷你尚硅谷你尚硅你好""，和一个子串 str2="尚硅谷你尚硅你"
2.现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1
暴力匹配算法
如果用暴力匹配的思路，并假设现在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.用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量的时间。(不可行!)
4.暴力匹配算法实现.
代码:
public class baolijiefa {
public static void main(String[] args) {
String s1 = "ZZHANGKE";
String s2 = "ZHANGKE";
System.out.println(bljf(s1, s2));
}
public static int bljf(String s1,String s2){
char []s11 = s1.toCharArray();
char []s22 = s2.toCharArray();
int s1len = s11.length;
int s2len = s22.length;
int i=0;
int j=0;
while (i<s1len&&j<s2len){
if(s11[i]==s22[j]){
i++;
j++;
}else {//若匹配不成功 令i = i-(j-1),j=0;
i=i-(j-1);
j=0;
}
}
if(j==s2len){
return i-j;
}
return -1;
}
}
KMP算法介绍(很详尽KMP算法（厉害） - ZzUuOo666 - 博客园)
1.KMP是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法
2.Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP算法”，常用于在一个文本串S内查找一个模式串P 的出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H. Morris三人于1977年联合发表，故取这3人的姓氏命名此算法.
3.KMP方法算法就利用之前判断过信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到，前面匹配过的位置，省去了大量的计算时间
KMP算法最佳应用-字符串匹配问题
字符串匹配问题：
1.有一个字符串 str1= "BBC ABCDAB ABCDABCDABDE"，和一个子串str2="ABCDABD"
2.现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1
3.要求：使用KMP算法完成判断，不能使用简单的暴力匹配算法.
举例来说，有一个字符串 Str1 = “BBC ABCDAB ABCDABCDABDE”，判断，里面是否包含另一个字符串 Str2 = “ABCDABD”？
1.首先，用Str1的第一个字符和Str2的第一个字符去比较，不符合，关键词向后移动一位
- 重复第一步，还是不符合，再后移
- 一直重复，直到Str1有一个字符与Str2的第一个字符符合为止
- 接着比较字符串和搜索词的下一个字符，还是符合。
5.遇到Str1有一个字符与Str2对应的字符不符合。
6.这时候，想到的是继续遍历Str1的下一个字符，重复第1步。(其实是很不明智的，因为此时BCD已经比较过了，没有必要再做重复的工作，一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是”ABCDAB”。KMP 算法的想法是，设法利用这个已知信息，不要把”搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。)
7.怎么做到把刚刚重复的步骤省略掉？可以对Str2计算出一张《部分匹配表》，这张表的产生在后面介绍
8.已知空格与D不匹配时，前面六个字符”ABCDAB”是匹配的。查表可知，最后一个匹配字符B对应的”部分匹配值”为2，因此按照下面的公式算出向后移动的位数：
移动位数 = 已匹配的字符数 - 对应的部分匹配值
因为 6 - 2 等于4，所以将搜索词向后移动 4 位。
9.因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（”AB”），对应的”部分匹配值”为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移 2 位。
10.因为空格与A不匹配，继续后移一位。
11.逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动 4 位。
12.逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动 7 位，这里就不再重复了。
13.介绍《部分匹配表》怎么产生的
先介绍前缀，后缀是什么
“部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”ABCDABD”为例，
－”A”的前缀和后缀都为空集，共有元素的长度为0；
－”AB”的前缀为[A]，后缀为[B]，共有元素的长度为0；
－”ABC”的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；
－”ABCD”的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；
－”ABCDA”的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为”A”，长度为1；
－”ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为”AB”，长度为2；
－”ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。
14.”部分匹配”的实质是，有时候，字符串头部和尾部会有重复。比如，”ABCDAB”之中有两个”AB”，那么它的”部分匹配值”就是2（”AB”的长度）。搜索词移动的时候，第一个”AB”向后移动 4 位（字符串长度-部分匹配值），就可以来到第二个”AB”的位置。 
代码:
public class KMPDemo {
public static void main(String[] args) {
String s1 = "BBC ABCDAB ABCDABCDABDE";
String s2 = "ABCDABD";
int []next = kmpNext("ABCDABD");
System.out.println(KMP(s1, s2,next));
}
//获取一个字符串(子串)的部分匹配值表
public static int[] kmpNext(String dest){
//创建一个next数组 保存部分匹配值
int[]next = new int[dest.length()];
next[0]=0;//若字符串长度为1 部分匹配值为0
//－”A”的前缀和后缀都为空集，共有元素的长度为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)时 推出
while (j>0&&dest.charAt(i)!=dest.charAt(j) ){
j=next[j-1];
}
//此时 部分匹配值就需要+1
if(dest.charAt(i)==dest.charAt(j)){
j++;
}
next[i]=j;
}
return next;
}
//kmp搜索算法
private static int KMP(String s1, String s2,int []next) {
//遍历
for (int i = 0,j=0; i <s1.length() ; i++) {
//需要处理s1.charAt(i)!=s2.charAt(j) 去调整j的大小
//kmp算法核心点
while (j>0&&s1.charAt(i)!=s2.charAt(j) ){
j=next[j-1];
}
if(s1.charAt(i)==s2.charAt(j)){
j++;
}
if (j==s2.length()){
return i-j+1;
}
}
return -1;
}
}
贪心算法
贪心算法介绍
①贪婪算法(贪心算法)是指在对问题进行求解时，在每一步选择中都采取最好或者最优(即最有利)的选择，从而希望能够导致结果是最好或者最优的算法
②贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解)，但是都是相对近似(接近)最优解的结果
应用场景-集合覆盖问题
假设存在下面需要付费的广播台，以及广播台信号可以覆盖的地区。 如何选择最少的广播台，让所有的地区都可以接收到信号
思路分析:
如何找出覆盖所有地区的广播台的集合呢，使用穷举法实现,列出每个可能的广播台的集合，这被称为幂集。假设总的有n个广播台，则广播台的组合总共有 2ⁿ -1 个,假设每秒可以计算10个子集， 如图:
| 广播台数量n | 子集总数2ⁿ | 需要的时间 |
| 5 | 32 | 3.2秒 |
| 10 | 1024 | 102.4秒 |
| 32 | 4294967296 | 13.6年 |
| 100 | 1.26*100³º | 4x10²³年 |
使用贪婪算法，效率高: 目前并没有算法可以快速计算得到准备的值， 使用贪婪算法，则可以得到非常接近的解，并且效率高。选择策略上，因为需要覆盖全部地区的最小集合:
1.遍历所有的广播电台, 找到一个覆盖了最多未覆盖的地区的电台(此电台可能包含一些已覆盖的地区，但没有关系）
2.将这个电台加入到一个集合中(比如ArrayList), 想办法把该电台覆盖的地区在下次比较时去掉。
3.重复第1步直到覆盖了全部的地区
代码:
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
public class greedy {
public static void main(String[] args) {
//创建广播电台 放到HashMap中
HashMap<String, HashSet> broadcasts = new HashMap<>();
//将各个电台放入broadcasts
HashSet<String> hashSet1 = new HashSet<>();
HashSet<String> hashSet2 = new HashSet<>();
HashSet<String> hashSet3 = new HashSet<>();
HashSet<String> hashSet4 = new HashSet<>();
HashSet<String> hashSet5 = new HashSet<>();
hashSet1.add("北京");
hashSet1.add("上海");
hashSet1.add("天津");
hashSet2.add("广州");
hashSet2.add("北京");
hashSet2.add("深圳");
hashSet3.add("成都");
hashSet3.add("上海");
hashSet3.add("深圳");
hashSet4.add("上海");
hashSet4.add("天津");
hashSet5.add("杭州");
hashSet5.add("大连");
broadcasts.put("K1",hashSet1);
broadcasts.put("K2",hashSet2);
broadcasts.put("K3",hashSet3);
broadcasts.put("K4",hashSet4);
broadcasts.put("K5",hashSet5);
//存放所有的地区
HashSet<String> allAreas = new HashSet<>();
allAreas.add("北京");
allAreas.add("上海");
allAreas.add("广州");
allAreas.add("大连");
allAreas.add("深圳");
allAreas.add("杭州");
allAreas.add("天津");
allAreas.add("成都");
//创建ArrayList 存放选择的电台集合
ArrayList<String> selects = new ArrayList<>();
//定义一个临时集合 在遍历的过程中 存放遍历过程中电台覆盖的地区 和 当前还没有覆盖的地区的交集
ArrayList<String> tempSet = new ArrayList<>();
//定义一个maxKey 保存在一次遍历过程中 能够覆盖最大未覆盖的地区对应的电台的key
String maxKey = null;
//若maxKey不为空 则加入selects
while (allAreas.size()!=0){//不为0 则没有覆盖到所有的地区
maxKey = null;
//遍历broadcasts 取出key
for (String key:broadcasts.keySet()) {
tempSet.clear();
//当前的key能覆盖的地区
HashSet areas = broadcasts.get(key);
tempSet.addAll(areas);
//求交集 交集会赋给tempSet
tempSet.retainAll(allAreas);
if ((tempSet.size()>0)&&(maxKey==null||tempSet.size()>broadcasts.get(maxKey).size())){
maxKey=key;
}
//tempSet.size()>broadcasts.get(maxKey).size()这句话体现了贪心算法的特点 每次都选最优的
}
if(maxKey!=null){
selects.add(maxKey);
//将maxKey指向的广播覆盖的地区 从allAreas中去掉
allAreas.removeAll(broadcasts.get(maxKey));
}
}
System.out.println(selects);
}
}
贪心算法注意事项和细节
1.贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解)，但是都是相对近似(接近)最优解的结果
2.比如上题的算法选出的是K1, K2, K3, K5，符合覆盖了全部的地区
3.但是我们发现 K2, K3,K4,K5 也可以覆盖全部地区，如果K2 的使用成本低于K1,那么我们上题的 K1, K2, K3, K5 虽然是满足条件，但是并不是最优的.
普里姆算法和克鲁斯卡尔算法
最小生成树
修路问题本质就是就是最小生成树问题， 先介绍一下最小生成树(Minimum Cost Spanning Tree)，简称MST。
1.给定一个带权的无向连通图,如何选取一棵生成树,使树上所有边上权的总和为最小,这叫最小生成树
2.N个顶点，一定有N-1条边
3.包含全部顶点
4.N-1条边都在图中
5.举例说明(如图:) 求最小生成树的算法主要是普里姆 算法和克鲁斯卡尔算法
普里姆算法介绍
1.普利姆(Prim)算法求最小生成树，也就是在包含n个顶点的连通图中，找出只有(n-1)条边包含所有n个顶点的连通子图，也就是所谓的极小连通子图
2.普利姆的算法如下:
①设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条边
普里姆算法最佳实践(修路问题)
1.从顶点A开始处理<A,G>
A->C(7) A->G(2) A->B(5)
2.从<A,G>开始,将A和G的顶点和他们相邻的顶点还没有访问的顶点进行处理 <A,G,B>
A->C(7) A->B(5) G->E(4) G->F(6) G->B(3)
3.<A,G,B>开始,将A、B和G的顶点和他们相邻的顶点还没有访问的顶点进行处理<A,G,B,E>
A->C(7) G->E(4) G->F(6) B->D(9)
........
4.<A,G,B,E,F>
5.<A,G,B,E,F,D>
6.<A,G,B,E,F,D,C>
代码:
import java.util.Arrays;
public class prim {
public static void main(String[] args) {
char[]data = {'A','B','C','D','E','F','G'};
int verxs = data.length;
//邻接矩阵的关系使用二维数组表示
int [][]weight=new int[][]{
{1000,5,7,1000,1000,1000,2},
{5,1000,1000,9,1000,1000,3},
{7,1000,1000,1000,8,1000,1000},
{1000,9,1000,1000,1000,4,1000},
{1000,1000,8,1000,1000,5,4},
{1000,1000,1000,4,5,1000,6},
{2,3,1000,1000,4,6,1000}
};
MGraph mGraph = new MGraph(verxs);
MinTree minTree = new MinTree();
minTree.createGraph(mGraph,verxs,data,weight);
minTree.showGraph(mGraph);
minTree.prim1(mGraph,0);
}
}
//创建最小生成树
class MinTree{
//创建图的邻接矩阵
public void createGraph(MGraph mGraph,int verxs,char[]data,int [][]weight){
int i,j;
for(i=0;i<verxs;i++){
mGraph.data[i]=data[i];
for ( j = 0; j <verxs ; j++) {
mGraph.weight[i][j] = weight[i][j];
}
}
}
//显示图的方法
public void showGraph(MGraph mGraph){
for (int []link: mGraph.weight) {
System.out.println(Arrays.toString(link));
}
}
//编写prim算法 得到最小生成树
/**
*
* @param mGraph
* @param v 从哪个顶点开始
*/
public void prim1(MGraph mGraph,int v){
/**
* visited 标记是否访问 默认值都是0 表示没有访问过
*/
int[] visited = new int[mGraph.verxs];
for (int i = 0; i < mGraph.verxs; i++) {
visited[i]=0;
}
//把点前结点标记已经访问
visited[v] = 1;
int h1 = -1,h2=-1;//用两个变量记录两个顶点的下标
int minWeight = 1000;
for (int i = 1; i < mGraph.verxs; i++) {//因为有mGraph.verxs 所以prim算法后会生成mGraph.verxs-1条边
for (int j = 0; j < mGraph.verxs; j++) {
for (int k = 0; k < mGraph.verxs; k++) {
if(visited[j]==1&&visited[k]==0&&mGraph.weight[j][k]<minWeight){
minWeight = mGraph.weight[j][k];
h1 = j;
h2 = k;
}
}
}
//找到一条边
System.out.println(mGraph.data[h1] + "," + mGraph.data[h2] + " " + minWeight);
visited[h2]=1;
minWeight = 1000;
}
}
}
class MGraph{
int verxs;//图结点的个数
char []data;//结点的数据
int [][]weight;//存放边 即为邻接矩阵
public MGraph(int verxs) {
this.verxs = verxs;
data = new char[verxs];
weight = new int[verxs][verxs];
}
}
克鲁斯卡尔算法
克鲁斯卡尔算法介绍
1.克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。
2.基本思想：按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路
3.具体做法：首先构造一个只含n个顶点的森林，然后依权值从小到大从连通网中选择边
加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止
克鲁斯卡尔最佳实践-公交站问题 
代码:
import java.util.Arrays;
public class kruskal {
public int edgeNum;//边的个数
public char[] vertexes;//顶点数组
private int[][] matrix;//邻接矩阵
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=new int[][]{
{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}
};
kruskal kruskal1 = new kruskal(vertexes, matrix);
kruskal1.krusk();
}
//构造器
public kruskal(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.vertexes = vertexes
//初始化边
this.matrix = new int[vlen][vlen];
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
this.matrix[i][j] = matrix[i][j];
}
}
//统计边
for (int i = 0; i < vlen; i++) {
for (int j = i+1; j < vlen; j++) {
if (this.matrix[i][j] != INF) {
edgeNum++;
}
}
}
}
//打印邻接矩阵
public void print(){
for (int i = 0; i < vertexes.length; i++) {
for (int j = 0; j < vertexes.length; j++) {
System.out.printf("%15d",matrix[i][j]);
}
System.out.println();
}
}
public void krusk(){
int index = 0;//表示最后结果数组的索引
int[] ends = new int[edgeNum];//用于保存"已有最小生成树"中的每个顶点在最小生成树中的终点
//创建结果数组 保存最后的最小生成树
EData[]res = new EData[edgeNum];
//获取图中所有边的集合 一共有12条边
EData[] edges = getEdges();
//按照边的权值大小 进行排序(从小到大)
sort(edges);
//遍历数组 将边添加到最小生成树中 判断准备加入的边是否形成了回路 若没有 就加入res
for (int i = 0; i <edgeNum; i++) {
//获取到第i条边的第一个顶点(起点)
int p1 = getPosition(edges[i].start);
int p2 = getPosition(edges[i].end);
//获取p1 在已有最小生成树中的终点
int end1 = getEnd(ends, p1);
//获取p2 在已有最小生成树中的终点
int end2 = getEnd(ends, p2);
if(end1!=end2){
ends[end1] = end2;
res[index++] = edges[i];
}
}
//输出res
for (int i = 0; i <index ; i++) {
System.out.println(res[i]);
}
}
//返回顶点对应的下标 比如A->0
private int getPosition(char ch){
for (int i = 0; i < vertexes.length; i++) {
if (vertexes[i]==ch){
return i;
}
}
return -1;
}
//获取图中的边 放到EData 后面需要遍历该数组 通过邻接矩阵来获取近
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;
}
//对边进行排序处理 冒泡
private void sort(EData[]arr){
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-i-1; j++) {
if(arr[j].weight>arr[j+1].weight){
EData t = arr[j];
arr[j] = arr[j+1];
arr[j+1] = t;
}
}
}
}
}
//创建一个类 它的对象实例就表示一条边
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=" + start +
", end=" + end +
", weight=" + weight +
'}';
}
}迪杰斯特拉算法
迪杰斯特拉(Dijkstra)算法介绍
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个结点到其他结点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。
迪杰斯特拉(Dijkstra)算法过程
设置出发顶点为v，顶点集合V{v1,v2,vi...}，v到V中各顶点的距离构成距离集合Dis，Dis{d1,d2,di...}，Dis集合记录着v到图中各顶点的距离(到自身可以看作0，v到vi距离对应为di)
①从Dis中选择值最小的di并移出Dis集合，同时移出V集合中对应的顶点vi，此时的v到vi即为最短路径
②更新Dis集合，更新规则为：比较v到V集合中顶点的距离值，与v通过vi到V集合中顶点的距离值，保留值较小的一个(同时也应该更新顶点的前驱节点为vi，表明是通过vi到达的) ③重复执行两步骤，直到最短路径顶点为目标顶点即可结束
迪杰斯特拉(Dijkstra)算法最佳应用-最短路径
①战争时期，胜利乡有7个村庄(A, B, C, D, E, F, G) ，现在有六个邮差，从G点出发，需要分别把邮件分别送到 A, B, C , D, E, F 六个村庄
②各个村庄的距离用边线表示(权) ，比如 A – B 距离 5公里
③问：如何计算出G村庄到 其它各个村庄的最短距离?
④如果从其它点出发到各个点的最短距离又是多少?
代码:
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,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);
//测试, 看看图的邻接矩阵是否ok
graph.showGraph();
//测试迪杰斯特拉算法
graph.dsj(2);//C
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下标顶点到周围顶点的距离和周围顶点的前驱顶点,
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 如果访问过，就返回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];
}
/**
* 继续选择并返回新的访问顶点， 比如这里的G 完后，就是 A点作为新的访问顶点(注意不是出发顶点)
* @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();
}
}
弗洛伊德算法
弗洛伊德(Floyd)算法介绍
1.和Dijkstra算法一样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名
2.弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径
3.迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径。
4.弗洛伊德算法 VS 迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每一个顶点到其他顶点的最短路径。
弗洛伊德(Floyd)算法图解分析
1.设置顶点vi到顶点vk的最短路径已知为Lik，顶点vk到vj的最短路径已知为Lkj，顶点vi到vj的路径为Lij，则vi到vj的最短路径为：min((Lik+Lkj),Lij)，vk的取值为图中所有顶点，则可获得vi到vj的最短路径
2.至于vi到vk的最短路径Lik或者vk到vj的最短路径Lkj，是以同样的方式获得
示例：求最短路径为例说明
第一轮循环中，以A(下标为：0)作为中间顶点，距离表和前驱关系更新为：
分析如下：
- 以A顶点作为中间顶点是，B->A->C的距离由N->9，同理C到B；C->A->G的距离由N->12，同理G到C
- 更换中间顶点，循环执行操作，直到所有顶点都作为中间顶点更新后，计算结束
代码:
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[] { 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 就是中间顶点的下标 [A, B, C, D, E, F, G]
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];//更新前驱顶点
}
}
}
}
}
}
马踏棋盘算法
1.马踏棋盘算法也被称为骑士周游问题
2.将马随机放在国际象棋的8×8棋盘Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格
骑士周游问题的解决步骤和思路
- 创建棋盘chessBoard,是一个二维数组
- 将当前位置设署为已经访问，然后根据当前位置，计算马儿还能走哪些位置, 并放入到一个集合中（ArrayList）,最多有8个位置，每走一步，就使用step+1
- 遍历ArrayList中存放的所有位置，看看哪个可以走通，如果走通，就继续，走 不通，就回流.
- 判断马儿是否完成了任务，使用step和应该走的哪比较，如果没有达到 数量，则表示没有完成任务，将整个棋盘置0 注意：马儿不同的走法（策略），会得到不同的结果，效率也会有影响（优化）
代码:
import java.awt.Point;
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) {
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 是第几步 ,初始位置就是第1步
*/
public static void traversalChessboard(int[][] chessboard, int row, int column, int step) {
chessboard[row][column] = step;
//row = 4 X = 8 column = 4 = 4 * 8 + 4 = 36
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
ArrayList<Point> ps = new ArrayList<Point>();
//创建一个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) {
// TODO Auto-generated method stub
//获取到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;
}
}
});
}
}
扫一扫
213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
