图的深度、广度优先搜索(JAVA实现)

原创 2012年03月25日 11:53:07

深度优先遍历:顾名思义,就是一条路走到黑,走到最深的地方。当无路可走时,就返回上一步向其他路走,若没有其他路,则在返回一层,本方法可以通过递归来实现,但这次我是使用栈来实现的,把每一层的数据存储在栈中,用boolean型的vis[MAXN][MAXN]数组记录是否访问过,其中通过使用栈来实现记录访问路径过程,以便于回溯:

import java.util.*;
public class DFS {

    /**
     * @param args
     */
    final static int MAXN = 100;
    static Scanner scan = new Scanner(System.in);
    public static class Stack    {
        int Depth;
        int Dot;
        Stack()    {
            Depth = -1;
            Dot = -1;
        }
        public int getTopDot()    {
            return Dot;
        }
        public int getDepth()    {
            return Depth;
        }
        public void PushDate(int dep,int dot)    {
            Depth = dep;
            Dot = dot;
            System.out.println(dot+" The depth is:"+dep);
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] Graph = new int[MAXN][MAXN];
        boolean[] vis = new boolean[MAXN];
        for(int i=0;i<MAXN;i++)    {
            Arrays.fill(Graph[i], 0);
        }
        Arrays.fill(vis, false);
        int base = 0;int top = 0;
        Stack[] stack = new Stack[MAXN];
        int n,m;//n为点数,m为边数
        n = scan.nextInt();
        m = scan.nextInt();
        for(int i=0;i<2*n;i++)    {
            stack[i]=new Stack();
        }
        for(int i=0;i<m;i++)    {
            int a,b;
            a = scan.nextInt();
            b = scan.nextInt();
            Graph[a][b] = Graph[b][a] = 1;
        }
        for(int i=0;i<n;i++)    {
            if(vis[i] == false)    {
                int dep = -1;
                int dot = -1;
                stack[top].PushDate(1, i);
                top++;
                vis[i] = true;
                while(base != top)    {
                    dot = stack[top-1].getTopDot();
                    for(int j=0;j<n;j++)    {
                        if(Graph[dot][j] == 1 && vis[j] == false)    {
                            dep = stack[top-1].getDepth()+1;
                            stack[top].PushDate(dep, j);
                            top++;
                            vis[j] = true;
                            break;
                        }
                        if(j == n-1)//如果无路可走,出栈
                            top--;
                    }
                    
                }
            }
        }
    }
}
广度优先搜索:每当遍历到一个节点时,先要将其四周的节点遍历一遍,因此就不得不使用队列来存储每一个点周边的四个点,并记录是第几轮访问的节点(可以记录搜索到某点的最短距离)。

import java.util.*;
public class BFS {
    /**
     * @param args
     */
    final static int MAXN = 100;
    static Scanner scan = new Scanner(System.in);
    public static class Queue    {
        public int Depth;
        public int Dot;
        Queue()    {
            Depth = -1;
            Dot = -1;
        }
        public void enterQueue(int dot,int dep)    {
            Dot = dot;
            Depth = dep;
            System.out.println(Dot+" "+"The Depth is:"+ Depth);
        }
        public int depDate()    {
            return Depth;
        }
        public int dotdate()    {
            return Dot;
        }
    };
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] Graph = new int[MAXN][MAXN];
        boolean[] vis = new boolean[MAXN];
        for(int i=0;i<MAXN;i++)    {
            Arrays.fill(Graph[i], 0);
        }
        Arrays.fill(vis, false);
        int base = 0;int top = 0;
        Queue[] queue = new Queue[MAXN];
        int n,m;//n为点数,m为边数
        n = scan.nextInt();
        m = scan.nextInt();
        for(int i=0;i<2*n;i++)    {
            queue[i]=new Queue();
        }
        for(int i=0;i<m;i++)    {
            int a,b;
            a = scan.nextInt();
            b = scan.nextInt();
            Graph[a][b] = Graph[b][a] = 1;
        }
        for(int i=0;i<n;i++)    {
            if(vis[i] == false)    {
                int dot = 0;int dep=0;
                queue[top].enterQueue(i, 1);
                top++;
                vis[i] = true;
                while(top != base)    {
                    dep=queue[base].depDate()+1;
                    dot=queue[base].dotdate();
                    for(int j=0;j<n;j++)    {
                        if(Graph[dot][j] == 1 && vis[j] == false)    {
                            queue[top].enterQueue(j, dep);
                            top++;
                            vis[j] = true;
                        }
                    }
                    base++;
                }
            }
        }
    }
}

用JAVA实现深度优先搜索

深度优先与广度优先搜索代码实现很相似,前者是利用了栈这种数据结构;而后者是利用了队列这种数据结构。下面看看代码是怎么实现的 /*****************************深度优先***...
  • u013679620
  • u013679620
  • 2015年01月13日 17:14
  • 886

基于图的深度优先搜索和广度优先搜索java实现

为了解15puzzle问题,了解了一下深度优先搜索和广度优先搜索。先来讨论一下深度优先搜索(DFS),深度优先的目的就是优先搜索距离起始顶点最远的那些路径,而广度优先搜索则是先搜索距离起始顶点最近的那...
  • u011638883
  • u011638883
  • 2013年12月06日 16:49
  • 7276

java实现图的深度优先搜索和广度优先搜索

java实现图的深度优先搜索和广度优先搜索
  • wu020708
  • wu020708
  • 2016年06月18日 12:51
  • 873

Java实现图的深度和广度优先遍历算法

最近要学习写网络爬虫,所以把图的深度和广度搜索都再温习一下。
  • u013761665
  • u013761665
  • 2015年08月11日 10:21
  • 12909

广度优先搜索(BFS)java实现

  • 2015年10月29日 22:38
  • 3KB
  • 下载

Java实现图的遍历(深度优先与广度优先遍历)

点击跳转到文章原文图的遍历所谓图的遍历,即对图中的每个节点进行访问,而对含有许多点的图遍历并不轻松,往往有如下两种遍历策略: 深度优先遍历 广度优先遍历 深度优先遍历深度优先遍历,即从初始节点开始访问...
  • xu__cg
  • xu__cg
  • 2016年09月27日 19:08
  • 1287

JAVA广度优先搜索---寻找从A点到B点最短路径

前言搜索界两大基础搜索算法分别是广度优先搜索和深度优先搜索。搜索算法可以用于寻找图的连通性。 一个普通的二维地图,从A点到B点,有两个问题。 能否到达? 怎样以最短的路径走到B点? 这是搜索算法能...
  • xubaifu1997
  • xubaifu1997
  • 2016年07月18日 15:53
  • 1094

Java实现数据结构之深度优先搜索DFS和广度优先搜索BFS

数据结构之深度优先搜索DFS和广度优先搜索BFS
  • u011863767
  • u011863767
  • 2016年10月06日 22:42
  • 858

(算法入门)基本图论-广度优先搜索之JAVA实现

广度优先算法是最简单的图搜索算法之一,也是许多重要的图算法的原形,从PRIM到Dijkstra都使用了类似于广度优先算法的思想。 其思想如下: 已知图G=(V,E)和一个源顶点s,广度优先搜索以一...
  • tumaolin94
  • tumaolin94
  • 2015年07月18日 15:34
  • 794

Java算法---华为oj迷宫问题求解(广度优先搜索)

一万年太久,只争朝夕,只有坚持,才能胜利,经过昨天的努力,解决了广度优先算法实现迷宫问题,题目在这里不赘述,如果不知道题目的请看我的上一篇博客Java算法---华为oj迷宫问题求解,这里面说的很详细,...
  • csdn_yaobo
  • csdn_yaobo
  • 2015年12月22日 11:38
  • 1747
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:图的深度、广度优先搜索(JAVA实现)
举报原因:
原因补充:

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