1 樹
1.1 完全二叉樹
asdf
1.1.1 共同部分
1.1.2 前序遍歷
完全二叉樹-前序遍歷.png
1.1.3 中序遍歷
完全二叉樹-中序遍歷.png
1.1.4 后序遍歷
完全二叉樹-后序遍歷.png
import java.util.*;
public class MyTree {
public static void main(String[] args) {
}
//已知節(jié)點(diǎn)總數(shù)，求樹的層數(shù)
public static int 求樹的層數(shù)(int 節(jié)點(diǎn)總數(shù)){
if(節(jié)點(diǎn)總數(shù)>0){
int 臨時(shí)變量=2;
int 返回值=1;
while(臨時(shí)變量<=節(jié)點(diǎn)總數(shù)){
臨時(shí)變量=臨時(shí)變量*2;
返回值++;
}
return 返回值;
}else{
return -1;
}
}
//已知樹的層樹，求樹的左側(cè)索引
public static ArrayList<Integer> 求樹的左側(cè)索引(int 樹的層樹){
ArrayList<Integer> 返回值=new ArrayList<>();
if(樹的層樹>0){
int 臨時(shí)變量=0;
for (int i = 0; i < 樹的層樹; i++) {
返回值.add(臨時(shí)變量);
臨時(shí)變量=臨時(shí)變量*2+1;
}
return 返回值;
}else{
返回值.add(-1);
return 返回值;
}
}
//求父節(jié)點(diǎn)索引
public static int 求父節(jié)點(diǎn)索引(int 自己的索引){
if(自己的索引==0){
return -1;
}
if(自己的索引>0){
return (自己的索引+1)/2-1;
}else{
return -1;
}
}
//求左兒子節(jié)點(diǎn)索引
public static int 求左兒子節(jié)點(diǎn)索引(int 自己的索引,int 節(jié)點(diǎn)總數(shù)){
if(自己的索引*2+1>節(jié)點(diǎn)總數(shù)-1){
return -1;
}else{
return 自己的索引*2+1;
}
}
//求右兒子節(jié)點(diǎn)索引
public static int 求右兒子節(jié)點(diǎn)索引(int 自己的索引,int 節(jié)點(diǎn)總數(shù)){
if(自己的索引*2+2>節(jié)點(diǎn)總數(shù)-1){
return -1;
}else{
return 自己的索引*2+2;
}
}
//返回最近的有右兄弟的祖宗
public static int 返回最近的有右兄弟的祖宗(int 自己的索引){
if(自己的索引==0){
return -1;
}
int 臨時(shí)變量=自己的索引;
for(;;){
臨時(shí)變量=求父節(jié)點(diǎn)索引(臨時(shí)變量);
if(臨時(shí)變量%2==1){
return 臨時(shí)變量;
}else if(臨時(shí)變量==0){
臨時(shí)變量=-1;
return 臨時(shí)變量;
}
}
}
//求最遠(yuǎn)左子孫
public static int 求最遠(yuǎn)左子孫(int 自己的索引,int 節(jié)點(diǎn)總數(shù)){
if(自己的索引*2+1>節(jié)點(diǎn)總數(shù)){
return -1;
}
int 返回值=自己的索引;
while(返回值*2+1<=節(jié)點(diǎn)總數(shù)-1){
返回值=返回值*2+1;
}
return 返回值;
}
//求自己的右兄弟
public static int 求自己的右兄弟(int 自己的索引,int 節(jié)點(diǎn)總數(shù)){
if(自己的索引%2==0){
return -1;
}
if(自己的索引+1<=節(jié)點(diǎn)總數(shù)-1){
return 自己的索引+1;
}else {
return -1;
}
}
//前序遍歷二叉樹
public static LinkedList<Integer> 前序遍歷二叉樹(int 節(jié)點(diǎn)總數(shù)){
LinkedList<Integer> 前序遍歷索引=new LinkedList<>();
int 當(dāng)前索引=0;
前序遍歷索引.add(當(dāng)前索引);
for(;;){
//有沒有左兒子
if(求左兒子節(jié)點(diǎn)索引(當(dāng)前索引,節(jié)點(diǎn)總數(shù))>0){ //有
當(dāng)前索引=求左兒子節(jié)點(diǎn)索引(當(dāng)前索引,節(jié)點(diǎn)總數(shù));
前序遍歷索引.add(當(dāng)前索引);
}else{ //沒有
//有沒有右兄弟
if(當(dāng)前索引%2==1&&當(dāng)前索引!=節(jié)點(diǎn)總數(shù)-1){ //有
//移動(dòng)到右兄弟
當(dāng)前索引++;
前序遍歷索引.add(當(dāng)前索引);
//查看它的祖宗有沒有右兄弟
if(返回最近的有右兄弟的祖宗(當(dāng)前索引)>0){ //有
當(dāng)前索引=返回最近的有右兄弟的祖宗(當(dāng)前索引)+1;
前序遍歷索引.add(當(dāng)前索引);
}else{ //沒有
break;
}
}else{ //沒有
//有沒有父親
if(當(dāng)前索引==0){ //沒有
break;
}else{ //有
//查看它的祖宗有沒有右兄弟
if(返回最近的有右兄弟的祖宗(當(dāng)前索引)>0){ //有
當(dāng)前索引=返回最近的有右兄弟的祖宗(當(dāng)前索引)+1;
前序遍歷索引.add(當(dāng)前索引);
}else{ //沒有
break;
}
}
}
}
}
return 前序遍歷索引;
}
//中序遍歷二叉樹
public static LinkedList<Integer> 中序遍歷二叉樹(int 節(jié)點(diǎn)總數(shù)) {
LinkedList<Integer> 中序遍歷索引 = new LinkedList<>();
int 當(dāng)前索引=求最遠(yuǎn)左子孫(0,節(jié)點(diǎn)總數(shù));
中序遍歷索引.add(當(dāng)前索引);
a:for(;;){
//是否有父親
if(求父節(jié)點(diǎn)索引(當(dāng)前索引)>=0){ //有
當(dāng)前索引=求父節(jié)點(diǎn)索引(當(dāng)前索引);
中序遍歷索引.add(當(dāng)前索引);
b:for(;;){
//有沒有右兒子
if(求右兒子節(jié)點(diǎn)索引(當(dāng)前索引,節(jié)點(diǎn)總數(shù))>0){ //有
int 右兒子節(jié)點(diǎn)=求右兒子節(jié)點(diǎn)索引(當(dāng)前索引,節(jié)點(diǎn)總數(shù));
//右孩子有沒有子孫
if(求左兒子節(jié)點(diǎn)索引(右兒子節(jié)點(diǎn),節(jié)點(diǎn)總數(shù))>0){ //有
當(dāng)前索引=求最遠(yuǎn)左子孫(右兒子節(jié)點(diǎn),節(jié)點(diǎn)總數(shù));
中序遍歷索引.add(當(dāng)前索引);
continue a;
}else{ //沒有
當(dāng)前索引=右兒子節(jié)點(diǎn);
中序遍歷索引.add(當(dāng)前索引);
//有沒有最近的有右兄弟的祖宗
if(返回最近的有右兄弟的祖宗(當(dāng)前索引)==-1){ //沒有
break a;
}else{ //有
當(dāng)前索引=求父節(jié)點(diǎn)索引(返回最近的有右兄弟的祖宗(當(dāng)前索引));
中序遍歷索引.add(當(dāng)前索引);
continue b;
}
}
}else{ //沒有
//自己有沒有有兄弟
if(求自己的右兄弟(當(dāng)前索引,節(jié)點(diǎn)總數(shù))>0){ //有
continue a;
}else{ //沒有
//有沒有最近的有右兄弟的祖宗
if(返回最近的有右兄弟的祖宗(當(dāng)前索引)==-1){ //沒有
break a;
}else{ //有
當(dāng)前索引=求父節(jié)點(diǎn)索引(返回最近的有右兄弟的祖宗(當(dāng)前索引));
中序遍歷索引.add(當(dāng)前索引);
continue b;
}
}
}
}
}else{ //沒有
break a;
}
}
return 中序遍歷索引;
}
//后序遍歷二叉樹
public static LinkedList<Integer> 后序遍歷二叉樹(int 節(jié)點(diǎn)總數(shù)) {
LinkedList<Integer> 后序遍歷索引 = new LinkedList<>();
int 當(dāng)前索引=求最遠(yuǎn)左子孫(0,節(jié)點(diǎn)總數(shù));
后序遍歷索引.add(當(dāng)前索引);
for (;;){
//有沒有右兄弟？
if(求自己的右兄弟(當(dāng)前索引,節(jié)點(diǎn)總數(shù))>0){ //有
int 自己的右兄弟=求自己的右兄弟(當(dāng)前索引,節(jié)點(diǎn)總數(shù));
//右兄弟有沒有子孫？
if(求左兒子節(jié)點(diǎn)索引(自己的右兄弟,節(jié)點(diǎn)總數(shù))>0){ //有
當(dāng)前索引=求最遠(yuǎn)左子孫(自己的右兄弟,節(jié)點(diǎn)總數(shù));
后序遍歷索引.add(當(dāng)前索引);
continue;
}else{ //沒有
當(dāng)前索引=自己的右兄弟;
后序遍歷索引.add(當(dāng)前索引);
continue;
}
}else{ //沒有
//有沒有父親？
if(求父節(jié)點(diǎn)索引(當(dāng)前索引)>=0){ //有
當(dāng)前索引=求父節(jié)點(diǎn)索引(當(dāng)前索引);
后序遍歷索引.add(當(dāng)前索引);
continue;
}else{ //沒有
break;
}
}
}
return 后序遍歷索引;
}
}
2 排列
2.1 二分法插入排序
3 圖論
3.1 構(gòu)建圖
構(gòu)件圖.png
public class Graph{
public static void main(String[] args) {
Integer[] guanxi={
//0,1,2,3,4,5,6,7,8
0,1,5,0,0,0,0,0,0, //0
1,0,3,7,5,0,0,0,0, //1
5,3,0,0,1,7,0,0,0, //2
0,7,0,0,2,0,3,0,0, //3
0,5,1,2,0,3,6,9,0, //4
0,0,7,0,3,0,0,5,0, //5
0,0,0,3,6,0,0,2,7, //6
0,0,0,0,9,5,2,0,4, //7
0,0,0,0,0,0,7,4,0, //8
};
String[] hang={"0","1","2","3","4","5","6","7","8"};
String[] lie={"0","1","2","3","4","5","6","7","8"};
ArrayList<String> 行=new ArrayList<>(Arrays.asList(hang));
ArrayList<String> 列=new ArrayList<>(Arrays.asList(lie));
ArrayList<Integer> 關(guān)系=new ArrayList<>(Arrays.asList(guanxi));
///////////////////////////////////////////////////////////////////////
HashMap<Integer,ArrayList<HashMap<String,Object>>> 圖=構(gòu)建圖2(行,列,關(guān)系,"6");
}
public static HashMap<String,Integer> 求和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn)(ArrayList<String> 行,ArrayList<String> 列,
ArrayList<Integer> 關(guān)系,String 節(jié)點(diǎn)){
int 元素個(gè)數(shù)=行.size();
HashMap<String,Integer> 返回值=new HashMap<>();
int 關(guān)系里的起始索引=行.size()*列.indexOf(節(jié)點(diǎn));
int 關(guān)系里的結(jié)束索引=行.size()*(列.indexOf(節(jié)點(diǎn))+1)-1;
for (int j =關(guān)系里的起始索引; j <=關(guān)系里的結(jié)束索引 ; j++) {
if(關(guān)系.get(j)!=0){
返回值.put(行.get(j%元素個(gè)數(shù)),關(guān)系.get(j));
}
}
return 返回值;
}
public static HashMap<Integer,ArrayList<HashMap<String,Object>>> 構(gòu)建圖2(ArrayList<String> 行,ArrayList<String> 列,
ArrayList<Integer> 關(guān)系,String 頂點(diǎn)){
HashMap<Integer,ArrayList<HashMap<String,Object>>> 返回值=new HashMap<>();
int 元素個(gè)數(shù)=行.size();
//獲取根節(jié)點(diǎn)的連接節(jié)點(diǎn)
int 當(dāng)前層數(shù)=1;
if(當(dāng)前層數(shù)==1){
ArrayList<HashMap<String,Object>> 每層集合=new ArrayList<>();
ArrayList<String> 根節(jié)點(diǎn)的連接節(jié)點(diǎn)=new ArrayList<>();
HashMap<String,Object> 每層的每個(gè)元素=new HashMap<>();
每層的每個(gè)元素.put("元素", 頂點(diǎn));
int 關(guān)系里的起始索引=行.size()*列.indexOf(頂點(diǎn));
int 關(guān)系里的結(jié)束索引=行.size()*(列.indexOf(頂點(diǎn))+1)-1;
for (int j =關(guān)系里的起始索引; j <=關(guān)系里的結(jié)束索引 ; j++) {
if(關(guān)系.get(j)!=0){
根節(jié)點(diǎn)的連接節(jié)點(diǎn).add(行.get(j%元素個(gè)數(shù)));
}
}
每層的每個(gè)元素.put("兒子",根節(jié)點(diǎn)的連接節(jié)點(diǎn));
每層集合.add(每層的每個(gè)元素);
返回值.put(當(dāng)前層數(shù),每層集合 );
}
//第一層結(jié)束,進(jìn)入下一層
當(dāng)前層數(shù)++;
for(;;){
//上一層是否有兒子？
HashMap<String,ArrayList<String>> 上一層的兒子集合=new HashMap<>();
for (HashMap<String,Object> 每層的每個(gè)元素 : 返回值.get(當(dāng)前層數(shù)-1)) {
for (String 每個(gè)兒子 : (ArrayList<String>)每層的每個(gè)元素.get("兒子")) {
//上一層的兒子集合里有沒有每個(gè)兒子？
if(上一層的兒子集合.get(每個(gè)兒子)==null){ //沒有
ArrayList<String> 臨時(shí)數(shù)組=new ArrayList<>();
臨時(shí)數(shù)組.add((String)每層的每個(gè)元素.get("元素"));
上一層的兒子集合.put(每個(gè)兒子,臨時(shí)數(shù)組);
}else{ //有
上一層的兒子集合.get(每個(gè)兒子).add((String)每層的每個(gè)元素.get("元素"));
}
}
}
if(上一層的兒子集合.size()==0){ //上一層沒有兒子
break;
}else{ //上一層有兒子
Set<String> 上一層的兒子集合所有鍵=上一層的兒子集合.keySet();
ArrayList<HashMap<String,Object>> 每層集合=new ArrayList<>();
for (String 上一層的每個(gè)兒子 : 上一層的兒子集合所有鍵) {
HashMap<String,Object> 每層的每個(gè)元素=new HashMap<>();
ArrayList<String> 兄弟=new ArrayList<>();
ArrayList<String> 兒子=new ArrayList<>();
每層的每個(gè)元素.put("元素",上一層的每個(gè)兒子);
每層的每個(gè)元素.put("父親",上一層的兒子集合.get(上一層的每個(gè)兒子));
int 關(guān)系里的起始索引=元素個(gè)數(shù)*列.indexOf(上一層的每個(gè)兒子);
int 關(guān)系里的結(jié)束索引=元素個(gè)數(shù)*(列.indexOf(上一層的每個(gè)兒子)+1)-1;
for (int j =關(guān)系里的起始索引; j <=關(guān)系里的結(jié)束索引 ; j++) {
if(關(guān)系.get(j)!=0){
//System.out.println(行.get(j%元素個(gè)數(shù)));
if(上一層的兒子集合.get(上一層的每個(gè)兒子).contains(行.get(j%元素個(gè)數(shù)))){ //是父親
}else if(上一層的兒子集合所有鍵.contains(行.get(j%元素個(gè)數(shù)))){ //是兄弟
兄弟.add(行.get(j%元素個(gè)數(shù)));
}else{ //是兒子
兒子.add(行.get(j%元素個(gè)數(shù)));
}
}
}
每層的每個(gè)元素.put("本層所有元素",上一層的兒子集合所有鍵);
每層的每個(gè)元素.put("兒子",兒子);
每層的每個(gè)元素.put("兄弟",兄弟);
每層集合.add(每層的每個(gè)元素);
}
返回值.put(當(dāng)前層數(shù),每層集合);
當(dāng)前層數(shù)++;
}
}
return 返回值;
}
}
3.2 深度優(yōu)先搜搜
深度優(yōu)先搜索.png
public static void 深度優(yōu)先搜索(HashMap<Integer,ArrayList<HashMap<String,Object>>> 圖){
ArrayList<String> 返回值=new ArrayList<>();
int 當(dāng)前層數(shù)=1;
String 根節(jié)點(diǎn)=(String)圖.get(當(dāng)前層數(shù)).get(0).get("元素");
String 臨時(shí)變量=根節(jié)點(diǎn);
返回值.add(臨時(shí)變量);
b:for (;;){
//節(jié)點(diǎn)是否有未被遍歷過(guò)的兒子，且該兒子的父親列表中的第一個(gè)父親為自己？
boolean 前進(jìn)條件1=false;
ArrayList<String> 該節(jié)點(diǎn)的兒子列表=new ArrayList<>();
d:for (HashMap<String,Object> 每層的每個(gè)元素: 圖.get(當(dāng)前層數(shù))) {
if((String)每層的每個(gè)元素.get("元素")==臨時(shí)變量){
該節(jié)點(diǎn)的兒子列表=(ArrayList<String>)每層的每個(gè)元素.get("兒子");
break d;
}
}
//ArrayList<String> 該節(jié)點(diǎn)的兒子列表=(ArrayList<String>)圖.get(當(dāng)前層數(shù)).get(0).get("兒子");
// System.out.println("當(dāng)前節(jié)點(diǎn)："+臨時(shí)變量);
// System.out.println("當(dāng)前節(jié)點(diǎn)的兒子："+該節(jié)點(diǎn)的兒子列表);
a:for (String 每個(gè)兒子: 該節(jié)點(diǎn)的兒子列表) {
if(!返回值.contains(每個(gè)兒子)){
for (HashMap<String,Object> 每層的每個(gè)元素: 圖.get(當(dāng)前層數(shù)+1)) {
if((String)每層的每個(gè)元素.get("元素")==每個(gè)兒子&&
((ArrayList<String>)每層的每個(gè)元素.get("父親")).get(0)==臨時(shí)變量){
前進(jìn)條件1=true;
臨時(shí)變量=每個(gè)兒子;
break a;
}
}
}
}
if(前進(jìn)條件1){ //有
返回值.add(臨時(shí)變量);
當(dāng)前層數(shù)++;
continue b;
}else { //沒有
//該節(jié)點(diǎn)是否有父親？
boolean 前進(jìn)條件2=false;
if(當(dāng)前層數(shù)!=1){
c:for (HashMap<String,Object> 每層的每個(gè)元素: 圖.get(當(dāng)前層數(shù))) {
if((String)每層的每個(gè)元素.get("元素")==臨時(shí)變量){
前進(jìn)條件2=true;
臨時(shí)變量=((ArrayList<String>)每層的每個(gè)元素.get("父親")).get(0);
break c;
}
}
}
if(前進(jìn)條件2){ //有
當(dāng)前層數(shù)--;
continue b;
}else{ //沒有
break b;
}
}
}
System.out.println(返回值);
}
3.3 廣度優(yōu)先搜索
public static void 廣度優(yōu)先搜索(HashMap<Integer,ArrayList<HashMap<String,Object>>> 圖){
ArrayList<String> 返回值=new ArrayList<>();
for (int i = 1; i <=圖.size() ; i++) {
if(i==1){
返回值.add((String)圖.get(i).get(0).get("元素"));
}else{
Set<String> 臨時(shí)數(shù)組=new HashSet<>();
臨時(shí)數(shù)組=(Set<String>)圖.get(i).get(0).get("本層所有元素");
for (String str: 臨時(shí)數(shù)組) {
返回值.add(str);
}
}
}
System.out.println(返回值);
}
3.4 最小生成樹
3.4.1 普利姆
public static void 普里姆(ArrayList<String> 行,ArrayList<String> 列,
ArrayList<Integer> 關(guān)系,String 起始節(jié)點(diǎn)){
HashMap<String,Integer> 返回值=new HashMap<>();
ArrayList<String> 已使用的節(jié)點(diǎn)=new ArrayList<>();
已使用的節(jié)點(diǎn).add(起始節(jié)點(diǎn));
for(;;){
String 哪個(gè)已使用節(jié)點(diǎn)=null;
String 臨時(shí)節(jié)點(diǎn)=null;
int 目前最小權(quán)值=0;
for (String 每個(gè)節(jié)點(diǎn):已使用的節(jié)點(diǎn)) {
HashMap<String,Integer> 和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn)=求和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn)(行, 列, 關(guān)系, 每個(gè)節(jié)點(diǎn));
Set<String> 所有節(jié)點(diǎn)=和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn).keySet();
for (String str: 所有節(jié)點(diǎn)) {
if(!已使用的節(jié)點(diǎn).contains(str)){
if(目前最小權(quán)值==0){
目前最小權(quán)值=和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn).get(str);
臨時(shí)節(jié)點(diǎn)=str;
哪個(gè)已使用節(jié)點(diǎn)=每個(gè)節(jié)點(diǎn);
}else{
if(目前最小權(quán)值>和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn).get(str)){
目前最小權(quán)值=和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn).get(str);
臨時(shí)節(jié)點(diǎn)=str;
哪個(gè)已使用節(jié)點(diǎn)=每個(gè)節(jié)點(diǎn);
}
}
}
}
}
已使用的節(jié)點(diǎn).add(臨時(shí)節(jié)點(diǎn));
返回值.put(哪個(gè)已使用節(jié)點(diǎn)+"-"+臨時(shí)節(jié)點(diǎn),目前最小權(quán)值);
if(已使用的節(jié)點(diǎn).size()==行.size()){
break;
}
}
System.out.println(返回值);
}
3.4.2 克魯斯卡爾
public static void 克魯斯卡爾(ArrayList<String> 行,ArrayList<String> 列,
ArrayList<Integer> 關(guān)系,String 起始節(jié)點(diǎn)){
}
3.5 最短路徑
3.5.1 迪杰斯特拉
public static void 迪杰斯特拉(ArrayList<String> 行,ArrayList<String> 列,
ArrayList<Integer> 關(guān)系,String 起始節(jié)點(diǎn)){
LinkedList<String> 未遍歷=new LinkedList<>();
HashMap<String,Integer> 最短路徑權(quán)值=new HashMap<>();
最短路徑權(quán)值.put(起始節(jié)點(diǎn),0);
HashMap<String,ArrayList<String>> 最短路徑路程=new HashMap<>();
ArrayList<String> 初始最短路徑路程值=new ArrayList<>();
初始最短路徑路程值.add(起始節(jié)點(diǎn));
最短路徑路程.put(起始節(jié)點(diǎn),初始最短路徑路程值);
LinkedList<String> 臨時(shí)數(shù)組外部=new LinkedList<>();
臨時(shí)數(shù)組外部.add(起始節(jié)點(diǎn));
//初始化未遍歷對(duì)象
for (String str: 行) {
未遍歷.add(str);
}
while(未遍歷.size()!=0){
System.out.println("臨時(shí)數(shù)組外部"+臨時(shí)數(shù)組外部);
ArrayList<String> 臨時(shí)數(shù)組內(nèi)部=new ArrayList<>();
//臨時(shí)數(shù)組內(nèi)部需要排序
for (String str: 臨時(shí)數(shù)組外部) {
未遍歷.remove(str);
//111111111111111111111
HashMap<String,Integer> 關(guān)系表=求和某個(gè)節(jié)點(diǎn)連接的所有節(jié)點(diǎn)(行,列,關(guān)系,str);
Set<String> 關(guān)系表鍵集合=關(guān)系表.keySet();
System.out.println("str"+str);
System.out.println("關(guān)系表鍵集合"+關(guān)系表鍵集合);
//22222222222222222222
Set<String> 最短路徑權(quán)值鍵集合=最短路徑權(quán)值.keySet();
for (String str2: 關(guān)系表鍵集合) {
System.out.println("aaaaa:"+str2);
System.out.println(最短路徑權(quán)值鍵集合);
//3333333333333333
if(最短路徑權(quán)值鍵集合.contains(str2)){
//55555555555555555555555555555
int 上面的值=最短路徑權(quán)值.get(str)+關(guān)系表.get(str2);
int 下面的值=最短路徑權(quán)值.get(str2);
//777777777777777777777
if(上面的值>下面的值){
}
//8888888888888888888888
else{
最短路徑權(quán)值.put(str2,最短路徑權(quán)值.get(str)+關(guān)系表.get(str2));
ArrayList<String> linshi=new ArrayList<>();
for (String str3:最短路徑路程.get(str)) {
linshi.add(str3);
}
linshi.add(str2);
最短路徑路程.put(str2,linshi);
}
}
//4444444444444444
else{
//66666666666666666
最短路徑權(quán)值.put(str2,最短路徑權(quán)值.get(str)+關(guān)系表.get(str2));
ArrayList<String> linshi=new ArrayList<>();
for (String str3:最短路徑路程.get(str)) {
linshi.add(str3);
}
linshi.add(str2);
最短路徑路程.put(str2,linshi);
臨時(shí)數(shù)組內(nèi)部.add(str2);
}
}
}
臨時(shí)數(shù)組外部.clear();
for (String str4:臨時(shí)數(shù)組內(nèi)部) {
臨時(shí)數(shù)組外部.add(str4);
}
}
System.out.println(最短路徑權(quán)值);
System.out.println(最短路徑路程);
}
