深度优先遍历/广度优先遍历（递归+非递归java实现）

###深度优先遍历/广度优先遍历
首先上代码：

import java.util.LinkedList;
import java.util.Stack;
import java.util.Queue;


public class Graph{
	private int number = 9;
	private boolean[] flag;
	private String[] vertexs = {"A", "B", "C", "D", "E", "F", "G", "H", "I"};
	private int[][] edges = {
		{0, 1, 0, 0, 0, 1, 1, 0, 0},
		{1, 0, 1, 0, 0, 0, 1, 0, 1},
		{0, 1, 0, 1, 0, 0, 0, 0, 1},
		{0, 0, 1, 0, 1, 0, 1, 1, 1},
		{0, 0, 0, 1, 0, 1, 0, 1, 0},
		{1, 0, 0, 0, 1, 0, 1, 0, 0},
		{0, 1, 0, 1, 0, 1, 0, 1, 0},
		{0, 0, 0, 1, 1, 0, 1, 0, 0},
		{0, 1, 1, 1, 0, 0, 0, 0, 0},
	};
	public static void main(String[] args){
		Graph graph = new Graph();
		System.out.println("DFS递归");
		graph.DFSTraverse();
		System.out.println();
		System.out.println("DFS非递归");
		//graph.DFS_Map_tree();
		graph.DFS_Map();
		System.out.println();
		System.out.println("BFS非递归");
		graph.BFS_Map();
	}
	void DFSTraverse(){
		flag = new boolean[number];
		for(int i = 0; i < number; i++){
			if(flag[i] == false){
				DFS(i);
			}
		}
	}
	void DFS(int i){
		flag[i] = true;
		System.out.print(vertexs[i] + " ");
		for(int j = 0; j < number; j++){
			if(flag[j] == false && edges[i][j] == 1)
				DFS(j);
		}
	}
	void DFS_Map(){
		flag = new boolean[number];
		Stack<Integer> stack = new Stack<Integer>();
		for(int i = 0; i < number; i++){
			if(flag[i] == false){
				flag[i] = true;
				System.out.print(vertexs[i] + " ");
				stack.push(i);
			}
			while(!stack.isEmpty()){
				int k = stack.peek();
				int j = 0;
				for(j = 0; j < number; j++){
					if(edges[k][j] == 1 && flag[j] == false){
						flag[j] = true;
						System.out.print(vertexs[j] + " ");
						stack.push(j);
						break;
					}
				}
				if(j == number){
				    stack.pop();
				}
			}
		}
	}
	/*
	如果是树，可以用此思路，将打印放在出栈时，
	思路：对于每一个连通图，取一个未访问的节点入栈，只要栈不为空，循环：栈顶元素出栈并访问
	栈顶元素，将与栈顶元素有边且未被访问的元素入栈。所有连通分支访问完，算法结束。
	（每个栈顶元素先于与其有边且未被访问的元素被访问）
	*/
	/*void DFS_Map_tree(){
		flag = new boolean[number];
		Stack<Integer> stack = new Stack<Integer>();
		for(int i = 0; i < number; i++){
			if(flag[i] == false){
				flag[i] = true;
				//System.out.print(vertexs[i] + " ");
				stack.push(i);
			}
			while(!stack.isEmpty()){
				int k = stack.pop();
				System.out.print(vertexs[k] + " ");
				//for中将与k连接但是没被访问的节点入栈。
				for(int j = 0; j < number; j++){
					if(edges[k][j] == 1 && flag[j] == false){
						flag[j] = true;
						//System.out.print(vertexs[j] + " ");
						stack.push(j);
						//break;
					}
				}
			}
		}
	}*/
	void BFS_Map(){
		flag = new boolean[number];
		Queue<Integer> queue = new LinkedList<Integer>();
		for(int i = 0; i < number; i++){
			if(flag[i] == false){
				flag[i] = true;
				System.out.print(vertexs[i] + " ");
				queue.add(i);
				while(!queue.isEmpty()){
					int k = queue.poll();
					for(int j = 0; j < number; j++){
						if(edges[k][j] == 1 && flag[j] == false){
							flag[j] = true;
							System.out.print(vertexs[j] + " ");
							queue.add(j);
						}
					}
				}
			}
		}
	}
}

深度优先遍历使用栈来模拟。思路：

对于每一个连通分支{
	输出起始节点，修改访问标志且进栈；
	栈不空，循环{
		取栈顶元素（不出栈）；
		while（栈顶元素存在未被访问的邻接节点）{
			输出该（未被访问的）节点，修改访问标志且进栈；
			break;
		}
		if（栈顶元素不存在未被访问的邻接节点）栈顶元素出栈；
	}
}

###二叉树的最大深度
递归实现

public class TreeNode {
	int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
 }
public class TreeMaxDepth{
    public int maxDepth(TreeNode root) {
        return depth(root);
    }
    private int depth(TreeNode node){
        if(node != null){
            return max(depth(node.left) + 1, depth(node.right) + 1);
        }else{
            return 0;
        }
        
    }
    private int max(int x, int y){
        return (x>y) ? x:y;
    }
}

---

2018.9.3逻辑有点乱，下次再写。
感谢网友Linky1990，非递归的深度优先遍历有错误，已经修正，欢迎大家批评指正。