# 1. 广度优先搜索算法实现

package org.sky.graph;

import java.util.Scanner;

/**
* @description 广度优先搜索
* @author sky
* @date 2017/1/3
*/
//表结点，包含边的相关信息
@SuppressWarnings("unused")
private static class ArcNode{
int value;          //与弧或边相关的信息，如权值
ArcNode nextArc;    //指向下一条弧或边的指针

public ArcNode(int adjVex, int value) {
super();
this.value = value;
}

ArcNode(int adjvex, int value, ArcNode nextArc) {
super();
this.value = value;
this.nextArc = nextArc;
}

}

}

public int getValue() {
return value;
}

public void setValue(int value) {
this.value = value;
}

public ArcNode getNextArc() {
return nextArc;
}

public void setNextArc(ArcNode nextArc) {
this.nextArc = nextArc;
}
}

//头结点，对应图中的顶点
@SuppressWarnings("unused")
private static class VNode{
Object data;        //顶点信息
ArcNode firstArc;   //指向第一条依附该顶点的弧或边的指针

public VNode(Object data) {
super();
this.data = data;
}

public VNode(Object data, ArcNode firstArc) {
super();
this.data = data;
this.firstArc = firstArc;
}

public Object getData() {
return data;
}

public void setData(Object data) {
this.data = data;
}

public ArcNode getFirstArc() {
return firstArc;
}

public void setFirstArc(ArcNode firstArc) {
this.firstArc = firstArc;
}

}

private int numVex;     //图的当前顶点数
private int numArc;     //图的当前边数或弧数

private VNode[] vexs;   //存储表头结点，通常采用顺序存储结构

super();
}

public BreadthFirstSearch(int numVex, int numArc, VNode[] vexs) {
super();
this.numVex = numVex;
this.numArc = numArc;
this.vexs = vexs;
}

/**
* @Desciption 创建有向网
*/
public void createDN(){
Scanner sc = new Scanner(System.in);
System.out.println("请分别输入图的顶点数及边数");
numVex = sc.nextInt();
numArc = sc.nextInt();
vexs = new VNode[numVex];
System.out.println("请分别输入图的各个顶点：");
for(int v = 0; v < numVex; v++){
vexs[v] = new VNode(sc.next());
}
System.out.println("请输入各个边的来给你个顶点及其权值");
for(int k = 0; k < numArc; k++){
int v = locateVex(sc.next());
int u = locateVex(sc.next());
int value = sc.nextInt();
}
sc.close();
}

/**
* @Desciption 创建无向网
*/
public void createUDN(){
Scanner sc = new Scanner(System.in);
System.out.println("请分别输入图的顶点数及边数");
numVex = sc.nextInt();
numArc = sc.nextInt();
vexs = new VNode[numVex];
visited = new boolean[numVex];
System.out.println("请分别输入图的各个顶点：");
for(int v = 0; v < numVex; v++){
vexs[v] = new VNode(sc.next());
visited[v] = false;
}
System.out.println("请输入各个边的来给你个顶点及其权值");
for(int k = 0; k < numArc; k++){
int v = locateVex(sc.next());
int u = locateVex(sc.next());
int value = sc.nextInt();
}
sc.close();
}

/**
* @Desciption 返回与传入值相对应的定点位置
*/
public int locateVex(Object vex){
for(int v = 0; v < numVex; v++){
if(vexs[v].getData().equals(vex)){
return v;
}
}
return -1;
}

/**
* @Desciption 在位置v和u间添加边，并赋权值
*/
private void addArc(int v, int u, int value){
ArcNode arc = new ArcNode(u,value);
arc.setNextArc(vexs[v].getFirstArc());
vexs[v].setFirstArc(arc);
}

///////////////////////////////////////广度优先搜索//////////////////////////////////////////////
private boolean[] visited;      //访问标志数组
/**
* 广度优先遍历
*/
public void BFSTraverse(){
for(int v = 0; v < numVex; v++){
if(!visited[v]){                            //v尚未访问
visited[v] = true;
System.out.println(vexs[v].getData());  //输出访问的结点
queue.putLast(v);
while(!queue.isEmpty()){
int u = queue.pollFirst();          //队头元素出队并设置为u
for(int w = getFirstAdjVex(u); w >= 0; w = getNextAdjVex(u , w)){
if(!visited[w]){                //w为u的尚未访问的邻接顶点
visited[w] = true;
System.out.println(vexs[w].getData());   //输出访问的结点
queue.putLast(w);
}
}
}
}
}
}

/**
* 获取vexs[v]的第一个邻接弧的顶点位置
* @param vexs
* @param v
* @return vexs[v]的第一个邻接弧的顶点位置；若不存在，则返回-1
*/
if(vexs[v].firstArc != null){ //第一个邻接弧是否存在
}
return -1;
}

/**
* 获取vexs[v]的相对第一个邻接弧的下一个邻接弧的顶点位置
* @param v
* @param w
* @return vexs[v]的相对第一个邻接弧的下一个邻接弧的顶点位置；若不存在，则返回-1
*/
public int getNextAdjVex(int v, int w){
ArcNode temp =  vexs[v].firstArc;
int tempTail = -1;
while(temp != null){
temp = temp.nextArc;
if(temp != null){
break;
}
}else{
temp = temp.nextArc;
}
}
return tempTail;
}
}



# 2. 测试代码

package org.sky.graph;

public class TestGragh {
public static void main(String[] args){
bfs.createUDN();
bfs.BFSTraverse();
}
}


• 本文已收录于以下专栏：

## 【算法入门】广度/宽度优先搜索(BFS)

• raphealguo
• 2012年04月30日 02:58
• 69749

## [C++]广度优先搜索（BFS）（附例题）

• stary_yan
• 2016年05月08日 14:16
• 6901

## 深度优先搜索与广度优先搜索

• andyelvis
• 2007年08月06日 13:16
• 56361

## 【算法】广度优先搜索

• byplane
• 2016年09月06日 10:47
• 1140

• m0_37316917
• 2017年04月27日 21:26
• 1217

## 广度/宽度优先搜索(BFS)详解

1.前言 广度优先搜索（也称宽度优先搜索，缩写BFS，以下采用广度来描述）是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域，故得名。 一般可以用它做什么呢...
• yake827
• 2016年09月27日 11:17
• 2200

## BFS 广度优先搜索 解析

• wr132
• 2015年01月29日 18:09
• 1539

## 【算法小总结】广度优先搜索剖析

• u013517797
• 2014年08月01日 21:15
• 3143

## 【经典算法】图的深度优先搜索和广度优先搜索

• yeswenqian
• 2014年07月23日 21:41
• 4877

## BFS广度优先搜索——入门

BFS——广度优先搜索 广度优先搜索是通过对图的完全遍历来达到要求的点的算法。其对图的遍历是如同波浪一样，每层按照制定的方式一层一层向下搜。 如： ５ ５ ４ ２ ...
• ilblue
• 2016年10月26日 21:03
• 1997

举报原因： 您举报文章：图之广度优先搜索 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)