图的遍历BFS+DFS+Dijkstra算法的学习

图的深度优先遍历

代码实现

package 算法练习;

public class 图的深度优先遍历 {
	static int da=99999; 
	static int total=1;
	static int[][] arr=new int[6][6];
	//记录跳过的坐标
	static int[][] ans=new int[6][6];
	
	//跳到哪一行
	 static void dfs(int tiao)
	{
		 //不然会重复
		 total=total+1;
		 System.out.println("total"+total);
		if(total<=5)
		{	 
		 
		for(int i=1;i<=5;i++)
		{
				//tiao，i是否可以去到
			//这里面也要加一层判断，因为第一层递归有可能total=6，还在执行这个for循环
			if(total<=5)
				{if(arr[tiao][i]==1&&ans[tiao][i]!=1)
				{
					System.out.println(i);
					ans[i][tiao]=1;
					dfs(i);
				} 
				}
			else
			{break;}
			 }
		}
		
	}
		
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
    //创建矩阵记录图的情况
		
		
		//i=j的情况标0
		for(int i=1;i<=5;i++)
			{for(int j=1;j<=5;j++)
			{
				if(i==j)
			{
					arr[i][j]=0;
			}
				else
				{
					arr[i][j]=1;
				}
			}
			}
	
		arr[1][4]=da;
		arr[2][3]=da;
		arr[2][5]=da;
		arr[3][2]=da;
		arr[3][4]=da;
		arr[4][1]=da;
		arr[4][3]=da;
		arr[4][5]=da;
		arr[5][2]=da;
		arr[5][4]=da;
		for(int i=1;i<=5;i++)
		{
			for(int j=1;j<=5;j++)
				{
			System.out.print(arr[i][j]+" ");
		}
		System.out.println();
		}
		System.out.println(1);
		dfs(1);
		
	}

}

图的广度优先遍历

package 算法练习;

public class 广度优先遍历图 {
	static int da=99999; 
	static int[][] arr=new int[6][6];
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=1;i<=5;i++)
		{for(int j=1;j<=5;j++)
		{
			if(i==j)
		{
				arr[i][j]=0;
		}
			else
			{
				arr[i][j]=1;
			}
		}
		}

	arr[1][4]=da;
	arr[2][3]=da;
	arr[2][5]=da;
	arr[3][2]=da;
	arr[3][4]=da;
	arr[4][1]=da;
	arr[4][3]=da;
	arr[4][5]=da;
	arr[5][2]=da;
	arr[5][4]=da;
	//创建栈
	int head=0;
	int tail=0;
	int[] ans=new int[6];
	int total=0;
	ans[head]=1;
	System.out.println(1);
	int flag=0;
	//tail只用执行4次，因为剩下只有4个数
	while(tail<4)
	{
		for(int i=1;i<=5;i++)
		{
			if(tail<4)
			{
				if(arr[ans[head]][i]==1)
			{	tail=tail+1;
				ans[tail]=i;
				total=total+1;
				System.out.println(i);
				arr[i][ans[head]]=0;
			}
			}
//			else
//			{
//				flag=1;
//				break;
//				}	
	}
//		if(flag==1)
//		{
//			break;
//		}
		head=head+1;
	}
	}
}

城市地图-图的深度优先遍历
单向有权图

5 8
1 2 2
1 5 10
2 3 3
2 5 7
3 1 4
3 4 4
4 5 5
5 3 3
城市地图的代码实现

package 算法练习;

import java.util.Scanner;

public class 城市地图 {
	//有多少行
	static int[][] arr=new int[6][6];
	static int total=0;
	//记录是否走过
	static int[] ans=new int[6];
	public static void dfs(int tiao,int quan)
	{
		//如果走过
		if(ans[tiao]==1)
		{
			return;
		}
		
		if(tiao==5)
		{
			System.out.println(total);
			return;
		}
		
		int i=1;
		for(i=1;i<=5;i++)
		{
			if(arr[tiao][i]>0&&arr[tiao][i]<999)
			{
				//走过的不能重复走
				ans[tiao]=1;
			    total=total+arr[tiao][i];
				dfs(i,arr[tiao][i]);
				//消去
				//如果走过，if(ans[tiao]==1)，从这句话里回来的，就是跳转重复的要减回来
				total=total-arr[tiao][i];
				//消去的原因如1—>2->3->4->5有可能1->2->4->5也可以，如果不消去4就被判定还走过，执行不了1->2->4->5
				ans[tiao]=0;
			}
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		
		//有多少组数据
		int zu=in.nextInt();
		//行号
		int hang=0;
		int lie=0;
		int i=0;
		//先全部是999
		for(i=1;i<=5;i++)
			for(int j=1;j<=5;j++)
			{
				if(i!=j)
				{
					arr[i][j]=999;
				}
				else {
					arr[i][j]=0;
				}
			}
		for(i=1;i<=8;i++)
		{
			hang=in.nextInt();
			lie=in.nextInt();
			arr[hang][lie]=in.nextInt();
		}
		//
		for(i=1;i<=5;i++)
			{
			for(int j=1;j<=5;j++)
			{
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
			}
		dfs(1,0);
	}

}

Dijkstra算法——单源最短路
记录从1到2,3,4，5，6的最短路径长度

每次选取距离1最近的点，然后去更新
用dis数组去记录1到各种数值的答案
从2,3，4,5，6的比较中开始
剩下的再用如下图所示去做循环

package 算法练习;

public class Dijkstra {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
     int[][] arr=new int[7][7];
		//不能连通的都用999表示
		for(int i=1;i<=6;i++)
			for(int j=1;j<=6;j++)
			{
				arr[i][j]=999;
			}
		//记录连通的路径
		arr[1][2]=1;
		arr[1][3]=12;
		arr[2][3]=9;
		arr[2][4]=3;
		arr[3][5]=5;
		arr[4][3]=4;
		arr[4][5]=13;
		arr[4][6]=15;
		arr[5][6]=4;
		for(int i=1;i<=6;i++)
		{
		for(int j=1;j<=6;j++)
		{
			System.out.print(arr[i][j]+" ");
		}
		System.out.println();
		}
		//创建数组记录答案
		int[] dis=new int[7];
        //给dis赋值
		for(int i=1;i<=6;i++)
		{
			dis[i]=arr[1][i];
		}
		//遍历输出
//				for(int i=0;i<=6;i++)
//				{
//					System.out.print("dis["+i+"]"+dis[i]+" ");
//				}
        //记录最小坐标
		int zuo=2;
		//记录zuo是否比较过
		int[] ans=new int[7];
		//要比较4次，更新4次
		int min=0;
		for(int i=0;i<4;i++)
		{

			//在剩下的dis当中找到zuo，成为过zuo就不能再比较
			//这一步是找到ans[i]==0的dis，就是没成为过zuo的
			for(int j=2;j<=6;j++)
			{
				if(ans[j]==0)
				{
				min=j;
				}
			}
			//找到这些ans[i]==0的dis当中的最小值
			min=dis[min];
			for(int j=2;j<=6;j++)
			{
				if(ans[j]==0)
				{
					if(dis[j]<min)
					{
						min=dis[j];
						zuo=j;
					}
				}
			}
			ans[zuo]=1;
				//选择zuo可以到达的去更新
				for(int w=2;w<=6;w++)
				{
					if(arr[zuo][w]!=999)
					{
						if(dis[zuo]+arr[zuo][w]<dis[w])
						{
							dis[w]=dis[zuo]+arr[zuo][w];
//							System.out.print("dis["+i+"]"+dis[i]+" ");
						}
					}
				}
				for(int q=1;q<=6;q++)
				{
					System.out.print("dis["+q+"]"+dis[q]+" ");
				}
				System.out.println();
		}
		//遍历输出
		dis[1]=0;
		for(int i=1;i<=6;i++)
		{
			System.out.print("dis["+i+"]"+dis[i]+" ");
		}
	}

}