图之广度优先搜索

原创 2017年01月03日 11:55:15

广度优先搜索是图的另外一种遍历方法,该算法的实现需要附设标志数组和辅助队列 ;
算法思路:假设图中所有顶点均未被访问,从图中某顶点v出发,在访问了v之后依次访问v的各个未曾访问过的邻接点,然后分别从这些邻接点出发依次访问他们的邻接点,并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问,直至图中已被访问的顶点的邻接点都被访问到。若此时图中尚有未被访问的顶点,则另选图中一个未曾被访问的顶点作为起始点,重复上述过程。

下面给出广度度优先搜索的Java实现及其测试代码:

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

package org.sky.graph;

import java.util.Scanner;
import java.util.concurrent.LinkedBlockingDeque;

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

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

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

        public int getAdjVex() {
            return adjVex;
        }

        public void setAdjVex(int adjVex) {
            this.adjVex = adjVex;
        }

        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;   //存储表头结点,通常采用顺序存储结构

    public BreadthFirstSearch() {
        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();
            addArc(v,u,value);
        }
        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();
            addArc(v,u,value);
            addArc(u,v,value);
        }
        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(){
        LinkedBlockingDeque<Integer> queue = new LinkedBlockingDeque<Integer>(); //辅助队列
        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
     */
    public int getFirstAdjVex(int v){
        if(vexs[v].firstArc != null){ //第一个邻接弧是否存在
            return vexs[v].firstArc.adjVex;
        }
        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){
            if(temp.adjVex == w){
                temp = temp.nextArc;
                if(temp != null){
                    tempTail = temp.adjVex;
                    break;
                }               
            }else{
                temp = temp.nextArc;
            }
        }       
        return tempTail;
    }
}

2. 测试代码

package org.sky.graph;

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

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

广度/宽度优先搜索(BFS) 【算法入门】 郭志伟@SYSU:raphealguo(at)qq.com 2012/04/27 1.前言 广度优先搜索(也称宽度优先搜索,缩写BFS,以下采用广...
  • raphealguo
  • raphealguo
  • 2012年04月30日 02:58
  • 69749

[C++]广度优先搜索(BFS)(附例题)

广度优先搜索(BFS)(附例题)问题产生:Isenbaev是国外的一个大牛。现在有许多人要参加ACM ICPC。一共有n个组,每组3个人。同组的3个人都是队友。大家都想知道自己与大牛的最小距离是多少。...
  • stary_yan
  • stary_yan
  • 2016年05月08日 14:16
  • 6901

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

有两种常用的方法可用来搜索图:即深度优先搜索和广度优先搜索。它们最终都会到达所有连通的顶点。深度优先搜索通过栈来实现,而广度优先搜索通过队列来实现。  深度优先搜索:下面图中的数字显示了深度优先搜索顶...
  • andyelvis
  • andyelvis
  • 2007年08月06日 13:16
  • 56361

【算法】广度优先搜索

转载出处:rapheal@iteye:http://rapheal.iteye.com http://rapheal.iteye.com/blog/1526861 作者:raphealguo(...
  • byplane
  • byplane
  • 2016年09月06日 10:47
  • 1140

[数据结构]广度优先搜索算法(Breadth-First-Search,BFS)

广度优先搜索的概念 广度优先搜索(BFS)类似于二叉树的层序遍历算法,它的基本思想是:首先访问起始顶点v,然后由v出发,依次访问v的各个未被访问过的邻接顶点w1,w2,w3….wn,然后再依次访问w1...
  • m0_37316917
  • m0_37316917
  • 2017年04月27日 21:26
  • 1217

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

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

BFS 广度优先搜索 解析

1.概念:        广度优先搜索算法(Breadth-First-Search),又译作宽度优先搜索,或横向优先搜索,简称BFS,是一种图形搜索算法。简单的说,BFS是从根节点开始,沿着树的宽...
  • wr132
  • wr132
  • 2015年01月29日 18:09
  • 1539

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

广度优先搜索 以前一直用搜索用的都是深搜,因为听说有很多题能用广搜就能用深搜什么的。今天老老实实的去看广搜了,结果发现我之前想的太天真的,DFS和BFS不仅在性质上不同,而且对于某些题和某些情况,用...
  • u013517797
  • u013517797
  • 2014年08月01日 21:15
  • 3143

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

前面学习了图的邻接表存储,
  • yeswenqian
  • yeswenqian
  • 2014年07月23日 21:41
  • 4877

BFS广度优先搜索——入门

BFS——广度优先搜索 广度优先搜索是通过对图的完全遍历来达到要求的点的算法。其对图的遍历是如同波浪一样,每层按照制定的方式一层一层向下搜。 如: 5 5 4 2 ...
  • ilblue
  • ilblue
  • 2016年10月26日 21:03
  • 1997
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:图之广度优先搜索
举报原因:
原因补充:

(最多只允许输入30个字)