package Sword;

import java.util.Iterator;
import java.util.LinkedList;

public class DFS {
	public static void main(String[] args) {
		DFS g = new DFS(4);
		 
		g.addEdge(0, 1);
		g.addEdge(0, 2);
		g.addEdge(1, 2);
		g.addEdge(2, 0);
		g.addEdge(2, 3);
		g.addEdge(3, 3);
 
		System.out.println("下面是DFS搜索结果 " + "(从2号结点开始)");
		g.DFSTravel(2);

	}

	// ---- DFS访问无向图------------------------------------------------------

	// 结点
	private int v;
	

	// 邻接表
	LinkedList<Integer> neighbor[];

	// 图的构造方法
	DFS(int cv) {
		this.v = cv;
		
		neighbor = new LinkedList[cv];
		for (int i = 0; i < cv; ++i)
			neighbor[i] = new LinkedList();
	}

	// 向图中cv点添加边(cv,m)
	public void addEdge(int cv, int w) {
		neighbor[cv].add(w);
	}

	// 回溯函数
	public void DFSUtil(int cv, boolean[] visited) {
		// 标记当前结点为已访问（visited）并输出
		visited[cv] = true;
		System.out.print(cv + " ");

		// 访问当前的结点的所有邻接结点
		Iterator<Integer> i = neighbor[cv].listIterator();
		while (i.hasNext()) {
			int n = i.next();
			if (!visited[n])
				DFSUtil(n, visited);
		}
	}

	// DFS traversal. 用来回溯调用 DFSUtil()函数
	public void DFSTravel(int cv) {
		// 标记所有节点为未访问状态（ not visited），设置初始值为false。
		boolean[] visited = new boolean[this.v];
		// 回溯 DFS traversal
		DFSUtil(cv, visited);
	}

}

仿真结果：

下面是DFS搜索结果 (从2号结点开始)
2 0 1 3

3、2 DFS访问树（不一定是二叉树）

1、思想

DFS遍历树，可以使用递归（分为三种，前中后序遍历）或者非递归（使用栈），思想就是尽可能深地遍历完树的子节点。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜索。
相比较而言，而广度搜索BFS是尽可能按层遍历完子节点。

2、树的实现

树是一种特殊的有向图。列举一种表示方式：

public class TreeNode<V> {

    private V value;
    private List<TreeNode<V>> childList;//子节点列表

    public TreeNode(V value) {
        this.value = value;
    }

    public TreeNode(V value, List<TreeNode<V>> childList) {
        this.value = value;
        this.childList = childList;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }

    public List<TreeNode<V>> getChildList() {
        return childList;
    }

    public void setChildList(List<TreeNode<V>> childList) {
        this.childList = childList;
    }
}

3、递归实现DFS遍历树（更容易理解，还是就记这个吧，天啊噜）

public static <V> void dfs(TreeNode<V> tree, int depth) {
    if (tree != null) {
        //打印节点值以及深度
        System.out.println(tree.getValue().toString() + ",   " + depth);
        if (tree.getChildList() != null && !tree.getChildList().isEmpty()) {
            for (TreeNode<V> item : tree.getChildList()) {
                dfs(item, depth + 1);
            }
        }
    }
}

一般来说，递归实现DFS 算法又分为如下三种：

1）. 前序遍历(Pre-Order Traversal，根 - 左 - 右) ：指先访问根，然后访问子树的遍历方式

private static <V> void dfs(TreeNode<V> tree, int depth) {
    if (d != null) {
        //打印节点值以及深度
        System.out.println(tree.getValue().toString() + ",   " + depth);
        if (tree.getChildList() != null && !tree.getChildList().isEmpty()) {
            for (TreeNode<V> item : tree.getChildList()) {
                dfs(item, depth + 1);
            }
        }
    }
}

2）. 后序遍历(Post-Order Traversal，左 - 右 - 根)：指先访问子树，然后访问根的遍历方式

private static <V> void dfs(TreeNode<V> tree, int depth) {
    if (d != null) {
        if (tree.getChildList() != null && !tree.getChildList().isEmpty()) {
            for (TreeNode<V> item : tree.getChildList()) {
                dfs(item, depth + 1);
            }
        }
        //打印节点值以及深度
        System.out.println(tree.getValue().toString() + ",   " + depth);
    }
}

3）. 中序遍历(In-Order Traversal，左 - 根 - 右)：指先访问左（右）子树，然后访问根，最后访问右（左）子树的遍历方式。

中序遍历一般是用二叉树实现：

private static <V> void dfs(TreeNode<V> root, int depth) {
    if (root.getLeft() != null){
        dfs(root.getLeft(), depth + 1);
    }
    //打印节点值以及深度
    System.out.println(d.getValue().toString() + ",   " + depth);
    if (root.getRight() != null){
        dfs(root.getRight(), depth + 1);
    }
}

4、非递归实现DFS遍历树（栈）

深度优先遍历各个节点，可以使用堆（Stack）这种数据结构。stack的特点是是先进后出。对于右图例子，整个遍历过程如下：

首先将A节点压入堆中，stack（A）;
将A节点弹出，同时将A的子节点C，B压入堆中，此时B在堆的顶部，stack(B,C)；
将B节点弹出，同时将B的子节点E，D压入堆中，此时D在堆的顶部，stack（D,E,C）；
将D节点弹出，没有子节点压入,此时E在堆的顶部，stack（E，C）；
将E节点弹出，同时将E的子节点I压入，stack（I,C）；
...依次往下，最终遍历完成

对于右图来说深度优先遍历的结果就是：A,B,D,E,I,C,F,G,H.(假设先走子节点的的左侧)。

public static <V> void dfsNotRecursive(TreeNode<V> tree) {
    if (tree != null) {
        //次数之所以用 Map 只是为了保存节点的深度，
        //如果没有这个需求可以改为 Stack<TreeNode<V>>
        Stack<Map<TreeNode<V>, Integer>> stack = new Stack<>();
        Map<TreeNode<V>, Integer> root = new HashMap<>();
        root.put(tree, 0);
        stack.push(root);
        while (!stack.isEmpty()) {
            Map<TreeNode<V>, Integer> item = stack.pop();
            TreeNode<V> node = item.keySet().iterator().next();
            int depth = item.get(node);
            //打印节点值以及深度
            System.out.println(tree.getValue().toString() + ",   " + depth);
            if (node.getChildList() != null && !node.getChildList().isEmpty()) {
                for (TreeNode<V> treeNode : node.getChildList()) {
                    Map<TreeNode<V>, Integer> map = new HashMap<>();
                    map.put(treeNode, depth + 1);
                    stack.push(map);
                }
            }
        }
    }
}

收录于