这里采用的是邻接表的表示，代码如下：

邻接表

package adjecentList;

import java.util.ArrayList;
import java.util.List;

public class AdjecentList {

	private List<Node> nodes = new ArrayList<Node>();

	public List<Node> getNodes() {
		return nodes;
	}

	public void addNode(Node node){
		nodes.add(node);
	}
	
	public Node findNode(String info){
		for(Node node : nodes){
			if (node.getInfo().equals(info)) {
				return node;
			}
		}
		return null;
	}
	
	public Node findFirst(){
		if (nodes != null) {
			return nodes.get(0);
		}
		return null;
	}
}

边：

package adjecentList;

public class Edge {

	private Node front;
	private Node back;
	private Edge next;
	
	public Node getFront() {
		return front;
	}
	public Node getBack() {
		return back;
	}
	public void setFront(Node front) {
		this.front = front;
	}
	public void setBack(Node back) {
		this.back = back;
	}
	public String toString() {
		String s = "" + front.getInfo() + "-" + back.getInfo();
		return s;
	}
	public Edge getNext() {
		return next;
	}
	public void setNext(Edge next) {
		this.next = next;
	}
}

点：

package adjecentList;

public class Node {

	private String info;
    private Edge nextEdge;
    
	public String getInfo() {
		return info;
	}

	public void setInfo(String info) {
		this.info = info;
	}

	public Edge getNextEdge() {
		return nextEdge;
	}

	public void addEdge(Edge edge){
		if (this.getNextEdge() == null) 
			this.nextEdge = edge;
		else {
			Edge p = this.getNextEdge();
			while(p.getNext() != null)
				p = p.getNext();
			p.setNext(edge);
		}
	}

}

算法：

package algorithm;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import adjecentList.AdjecentList;
import adjecentList.Edge;
import adjecentList.Node;
import tool.IOTool;

/**
 * 未做输入格式检测
 * @author miracle
 *
 */
public class AlgorithmTool {

	private static String INPUT_NODE = "please input the node set: ";
	private static String INPUT_EDGE = "please input the edge set: ";
	
	public static void breadthFirstSearch(AdjecentList graph){
		Map<Node, Integer> visited = createVisit(graph);
		List<Edge> eSet = new ArrayList<Edge>();
		Node first = null;
		for(Node node : graph.getNodes()){
			if (visited.get(node) == 0) {
				first = node;
				break;
			}
		}
		if (first == null) 
			return;
		List<Node> queue = new ArrayList<>();
		queue.add(first);
		while(!queue.isEmpty()){
			Node queueNode = queue.get(0);
			queue.remove(0);
			visited.put(queueNode, 1);
			
			Edge edge = queueNode.getNextEdge();
			while (edge != null) {
				Node back = edge.getBack();
				if (visited.get(back) == 0) {
					eSet.add(edge);
					visited.put(back, 1);
					queue.add(back);
				}
				edge = edge.getNext();
			}
		}
		IOTool.print("DFS edges: ");
		for(Edge edge : eSet){
			System.out.println(edge);
		}
	}
	
	public static void depthFirstSearch(AdjecentList graph){
		Map<Node, Integer> visited = createVisit(graph);
		List<Edge> eSet = new ArrayList<Edge>();
		Node first = null;
		for(Node node : graph.getNodes()){
			if (visited.get(node) == 0) {
				first = node;
				break;
			}
		}
		if (first != null) {
			DFS(first, visited, eSet);
		}
		
		IOTool.print("DFS edges: ");
		for(Edge edge : eSet){
			System.out.println(edge);
		}
	}
	
	private static void DFS(Node node, Map<Node, Integer> visited, List<Edge> eSet){
		visited.put(node, 1);
		Edge edge = node.getNextEdge();
		while(edge != null){
			Node back = edge.getBack();
			if (visited.get(back) == 0) {
				eSet.add(edge);
				DFS(back,visited,eSet);
			}
			edge = edge.getNext();
		}
	}
	
	private static Map<Node, Integer> createVisit(AdjecentList graph){
		Map<Node, Integer> visited = new HashMap<Node, Integer>();
		for(Node node : graph.getNodes()){
			visited.put(node, 0);
		}
		return visited;
	}
	
	public static AdjecentList createGraph(){
		//输入点集
		IOTool.print(INPUT_NODE);
		String nodeStr = IOTool.getInput();
		String []nodeArray = nodeStr.split(",");
		
		AdjecentList graph = new AdjecentList();
		for(String nodeInfo : nodeArray){
			Node node = new Node();
			node.setInfo(nodeInfo);
			graph.addNode(node);
		}
		//输入边集
		IOTool.print(INPUT_EDGE);
		String edgeStr = IOTool.getInput();
		String []edgeArray = edgeStr.split(",");
		for(String edgeInfo : edgeArray){
			String []pair = edgeInfo.split("-");
			String frontNode = pair[0];
			String backNode = pair[1];
			
			Node front = graph.findNode(frontNode);
			Node back = graph.findNode(backNode);
			if (front != null && back != null) {
				Edge edge = new Edge();
				edge.setFront(front);
				edge.setBack(back);
				front.addEdge(edge);
			}
		}
		return graph;
	}
}

io：

package tool;

import java.util.Scanner;

public class IOTool {

	public static String getInput() {
		@SuppressWarnings("resource")
		Scanner scanner = new Scanner(System.in);
		String input = scanner.nextLine();
		return input;
	}

	public static void print(String s) {
		System.out.println(s);
	}
}

main：

package main;

import adjecentList.AdjecentList;
import algorithm.AlgorithmTool;

public class Main {

	public static void main(String[] args) {
		AdjecentList graph = AlgorithmTool.createGraph();
		AlgorithmTool.depthFirstSearch(graph);
		AlgorithmTool.breadthFirstSearch(graph);
	}

}

如果采用邻接表，那么dfs时间复杂度为O(m+n)，终于在书上找到一个特别在理的解释了。

把算法分为2部分：

1建立visit数组，用 O(n)

2找邻接点，总共是每一个点的度的和，明显为O(2m)。具体说就是对每一个点而言，它的每一个未访问过的邻接点要执行一次dfs操作。所以dfs的总数不会超过2m。

相加即可。