广度优先遍历算法的java实现

广度优先遍历算法，又称为广度优先搜索，简称BFS。实现代码如下：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
class Point{   //这个类用于邻接表，因为每一个顶点在邻接表中都存在一个指向其它顶点的指针域所以要将指针域和数据域封装成一个具体的类
 int data;
 EdegeNode nextPoint;
 public Point() {}
 public Point(int data)
 {
  this.data=data;
  this.nextPoint=null;
 }
 
}
class EdegeNode{   //边表结点类
  int adjvex;
  EdegeNode nextEdge;
  public EdegeNode() {}
  public EdegeNode(int adjvex)   //初始化边结点
  {
   this.adjvex=adjvex;
   this.nextEdge=null;
  }
}
//图邻接表的表示法
class Graph{
 Point[] point; 
 int numPoint;
 int numEdeges;
 public Graph() {}
 public Graph(int numPoint,int numEdeges)
 {
  this.numPoint=numPoint;
  this.numEdeges=numEdeges;
  point=new Point[numPoint];  //初始化点集数组
 }
 public static void createGraph(Graph graph,int j,int k)  //创建图
 {
  Scanner in=new Scanner(System.in);
  for(int i=0;i<j;i++)
  {
   System.out.println("请输入第"+(i+1)+"顶点的数据:");
   graph.point[i]=new Point(in.nextInt());   //录入顶点的数据域
  }
  for(int i=0;i<k;i++)   //初始化边表,这里使用到了链表中间的头插法
  {
   System.out.println("请输入第"+(i+1)+"条边的两端顶点坐标：");
   int p1=in.nextInt();
   int p2=in.nextInt();
   EdegeNode a=new EdegeNode(p2);         //记录出度
   a.nextEdge=graph.point[p1].nextPoint;  //头插法
   graph.point[p1].nextPoint=a;
//   EdegeNode b=new EdegeNode(p2);         //记录出度
//   b.adjvex=i;                            //记录入度
//   b.nextEdge=graph.point[p2].nextPoint;
//   graph.point[p2].nextPoint=b;  
  }
 }
}
//图得邻接矩阵的表示法
class Graph1{                        //图类
 int[] point;                     //顶点矩阵
    int[][] edge;                    //边集矩阵
 int numPoint;                    //顶点数量
 int numEdeges;                   //边的数量
 public Graph1() {}
 public Graph1(int numPoint,int numEdeges)
 {
  this.numEdeges=numEdeges;
  this.numPoint=numPoint;
  point=new int[numPoint];
  edge=new int[numPoint][numPoint];
 }
 //邻接矩阵的表示法
 public static void createGraph1(Graph1 graph,int j,int k){
  Scanner in=new Scanner(System.in);
  for(int i=0;i<j;i++) {
     System.out.println("请输入第"+(i+1)+"顶点的数据:");
     graph.point[i]=in.nextInt();         //录入顶点数据
  }
  for(int i=0;i<j;i++) {
   for(int h=0;h<j;h++)
   {
    graph.edge[i][h]=Integer.MAX_VALUE;      //将邻接矩阵所有的边初始化为最大整数值
   }
  }
  for(int i=0;i<k;i++)                    //录入所有的边值
  {
   System.out.println("请输入第"+(i+1)+"条边的两端顶点坐标：");
   int p1=in.nextInt();
   int p2=in.nextInt();
   graph.edge[p1][p2]=1;
   graph.edge[p2][p1]=1;
  }
 }   
}
public class dsd {
//邻接矩阵的广度优先遍历算法
public static boolean[] visited=new boolean[9];        //用来标记结点是否访问过 
public static void BFSTraverser(Graph1 a)
{
 int i,j;
 Queue<Integer>queue = new LinkedList<Integer>();                        //java内置的队列数据结构
 for(i=0;i<a.numPoint;i++)
 {
  dsd.visited[i]=false;                                                //初始化结点均为未访问过
 }
 for(i=0;i<a.numPoint;i++)
 {
  if(!visited[i])                                                  //顶点未访问过就表示为true
  {
   visited[i]=true;
   System.out.println(a.point[i]);                             //获得顶点的信息
   queue.offer(a.point[i]);                                    //将该顶点入队
   while(!queue.isEmpty())                                     //当该队列不为空
   {
    queue.remove();                                            //队头元素出队列
    for(j=0;j<a.numPoint;j++)                                  //用来判断其它顶点若与当前顶点存在边且未访问过
    {
     if(a.edge[i][j]==1&&!visited[j])
     {
      visited[j]=true;
      System.out.println(a.point[j]);
      queue.offer(a.point[j]);
     }
    }
   }
  }
 }
 
}
//邻接表的广度优先遍历算法的实现
public static void BFSTraverser(Graph a)
{
 int i;
 EdegeNode edge;
 Queue<Point>queue = new LinkedList<Point>();
 for(i=0;i<a.numPoint;i++)
  visited[i]=false;
 for(i=0;i<a.numPoint;i++)
 {
  if(!visited[i])
  {
   visited[i]=true;
   System.out.println(a.point[i].data);
   queue.offer(a.point[i]);
   while(!queue.isEmpty())                                     //当该队列不为空
   {
    queue.remove();                                            //删除队头元素
    edge=a.point[i].nextPoint;
    while(edge != null)
    {
     if(visited[edge.adjvex])
     {
      visited[edge.adjvex]=true;
      System.out.println(a.point[edge.adjvex].data);
      queue.offer(a.point[edge.adjvex]);
     }
     edge=edge.nextEdge;
    }
   }
  }
 }
}
public static void main(String[] args)
{
// Graph1 graph=new Graph1(9,15);
// graph.createGraph1(graph, graph.numPoint, graph.numEdeges);
// BFSTraverser(graph);
 Graph graph=new Graph(9,15);
 graph.createGraph(graph, graph.numPoint, graph.numEdeges);
 BFSTraverser(graph);
}
}