图的深度、广度优先搜索(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实现

为了解15puzzle问题,了解了一下深度优先搜索和广度优先搜索。先来讨论一下深度优先搜索(DFS),深度优先的目的就是优先搜索距离起始顶点最远的那些路径,而广度优先搜索则是先搜索距离起始顶点最近的那...

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

最近要学习写网络爬虫,所以把图的深度和广度搜索都再温习一下。

java语言实现图的深度优先遍历与广度优先遍历

import java.util.*; public class Graph {  // 存储节点信息  private Object[] vertices;  // 存储边的信息  pri...
  • chj97
  • chj97
  • 2011-10-05 17:24
  • 14135

Java用邻接矩阵实现广度优先

定义节点类://一个节点 class Vertex{ char label; boolean wasVisited; public Vertex(char label){ ...

每天一道算法题(六)深度优先算法(DFS)学习及Java实现

DFS的思想是从一个顶点V0开始,沿着一条路一直走到底,如果发现不能到达目标解,那就返回到上一个节点,然后从另一条路开始走到底

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

深度优先搜索介绍 图的深度优先搜索(Depth First Search),和树的先序遍历比较类似。 它的思想:假设初始状态是图中所有顶点均未被访问,则从某个顶点v出发,首先访问该顶点,然后依次从...

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

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

图的广度优先搜索(BFS)、深度优先搜索(DFS)(邻接矩阵法和邻接表法java实现)

图的广度优先搜索(BFS)、深度优先搜索(DFS) package ccnu.offer.graph;import java.util.ArrayList; import java.util.Arra...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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