DFS核心类：

package com.dfs;

import java.util.Stack;

/**
 * 图的DFS 非递归遍历算法
 * @author Administrator
 *
 */
public class DFS 
{
    private char[] vertices;		//存储顶点信息
    private int[][] arcs;			//存储边
    private boolean[] visited;		//顶点是否访问过
    private int vexnum;				//顶点个娄
    
    /**
     * 实例对象时需要传入的顶点的个数
     * @param n
     */
    public DFS(int n)
    {
        vexnum = n;
        
        vertices = new char[n];
        
        arcs = new int[n][n];
        
        visited = new boolean[n];
    }
    
    /**
     * 在顶点之间添加一条边
     * @param i
     * @param j
     */
    public void AddEdge(int i, int j)
    {
        if(i == j) return;
        
        arcs[i][j] = 1;
        arcs[j][i] = 1;
    }
    
    /**
     * 设置顶点的值
     * @param vertices
     */
    public void SetVertices(char[] vertices)
    {
        this.vertices = vertices;
    }
    
    /**
     * 访问第i个顶点元素
     * @param i
     */
    private void visit(int i)
    {
        System.out.print(" "+this.vertices[i]);
    }
    
    /**
     * 非递归实现
     */
    public void DFSByStack()
    {
        //初始化访问矩阵
        for(int i = 0; i<vexnum;i++)
        {
            visited[i] = false;
        }
        
        Stack<Integer> stack = new Stack<Integer>();
        
        stack.push(0);			//将第0个元素压入栈
        visited[0] = true;		//第0个元素已经访问
        visit(0);
        
        while(!stack.empty())
        {
            int k = stack.peek().intValue();		//访问栈顶元素但不出栈
            boolean needPop = true;
            
            for(int i=0;i<vexnum; i++)
            {
                if(arcs[k][i] == 1 && visited[i] == false)
                {
                    stack.push(i);			//将第i个元素压入栈
                    visited[i] = true;		//第i个元素已经访问
                    visit(i);
                    needPop = false;
                    
                    break;
                }
                
            }
            
            if(needPop)
            {
                stack.pop();
            }
        }
    }
    
    /****************************************下面为递归实现相关的代码************************************/
    
    /**
     * 当前结点的第一个邻接结点在邻接矩阵中的索引
     * @param i
     * @return
     */
    private int FirstNeighbor(int i)
    {
        for(int k =i;k<vexnum;k++)
        {
            if(arcs[i][k] == 1)
            {
                return k;
            }
        }
        
        return -1;		//表示没有相连接点
    }
    
    /**
     * 获取i顶点除j外的下一个连接点
     * @param i
     * @param j
     * @return
     */
    public int NextNeighbor(int i,int j)
    {
        for( int k = j + 1; k<vexnum;k++)
        {
            if(arcs[i][k] == 1)
            {
                return k;
            }
        }
        
        return -1;
    }
    
    /**
     * 内部方法
     * @param isVisited
     * @param i
     */
    private void _DFStraverse(boolean[] isVisited,int  i)
    {
        
        visited[i] = true;
        visit(i);
        
        int first = FirstNeighbor(i);
        
        while(first!=-1)
        {
            if(visited[first] == false)
            {
                _DFStraverse(isVisited,first);
            }
            first = NextNeighbor(i, first);
        }
    }
    
    /**
     * 对外方法
     */
    public void DFStraverse()
    {
        //初始化访问矩阵
        for(int k = 0; k<vexnum;k++)
        {
            visited[k] = false;
        }
                
        for(int k = 0; k<vexnum;k++)
        {
            if(!visited[k])
            {
                _DFStraverse(visited,k);
            }
            
        }
    }
    
    
    /****************************递归方式二*************************************/
    
    /**
     * 从第i个节点开始深度优先遍历
     * @param i
     */
    private void traverse(int i)
    {
        
        visited[i] = true;
       
        visit(i);

       
        for(int j=0;j<vexnum;j++)					 // 遍历邻接矩阵中第i个节点的直接联通关系
        {
           
            if(arcs[i][j]==1 && visited[j]==false)
            {
                traverse(j); 						// 目标节点与当前节点直接联通，并且该节点还没有被访问，递归
            }
        }
    }
    
 
    public void DFSTraverse2()
    {
    	
        for (int i = 0; i < vexnum; i++) 
        {
            visited[i] = false;
        }

        for(int i=0;i<vexnum;i++)
        {
            if(visited[i]==false)
            {
             
                traverse(i);
            }
        }
    }
    
    
    
    
    

}

测试类：

package com.dfs;

public class MainClass {

    
    public static void main(String[] args) 
    {
        
        char[] vertices = {'A','B','C','D','E','F','G','H','I'};
        DFS dfs = new DFS(8);
        
        dfs.SetVertices(vertices);
        
        dfs.AddEdge(0, 1);
        dfs.AddEdge(0, 5);
        
        dfs.AddEdge(1, 0);
        dfs.AddEdge(1, 2);
        dfs.AddEdge(1, 3);
        dfs.AddEdge(1, 4);
        
        dfs.AddEdge(2, 1);
        dfs.AddEdge(2, 6);
        
        dfs.AddEdge(3, 1);
        dfs.AddEdge(3, 7);
        
        dfs.AddEdge(4, 1);
        
        dfs.AddEdge(5, 0);
        
        System.out.println("非递归结果：");
        dfs.DFSByStack();
        
        System.out.println("\n下一个邻接点递归结果：");
        dfs.DFStraverse();
        

    }

}