104. 二叉树的最大深度 分治法递归+DFS+BFS

#104. 二叉树的最大深度

难度：简单

题目描述

解题思路

1、分治法递归

简单无脑递归，二叉树的递归感觉都是一个套路

 public int maxDepth(TreeNode root) {        
 	if(root == null)            
 		return 0;        
 	return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;    
 }

2、深度优先遍历DFS 栈

每入栈一个节点的时候顺便保存当前节点的深度，如果遇到叶子节点就更新深度。本来可以用Pair对来同时入栈节点和深度的，不知道为社么我报错找不到那个包，就用两个栈同步出栈入栈来实现，时间上慢了不少

public int maxDepth(TreeNode root) {        
	if(root == null)            
		return 0;        
	int max = 1;        
	Stack<TreeNode> stack = new Stack<>();        
	Stack<Integer> sdepth = new Stack<>();        
	stack.push(root);        
	sdepth.push(1);        
	while(!stack.isEmpty() && !sdepth.isEmpty()) {            
		TreeNode temp = stack.pop();            
		int depth = sdepth.pop();            
		if(temp.right != null) {                
			stack.push(temp.right);                
			sdepth.push(depth+1);            
		}            
		if(temp.left != null) {                
			stack.push(temp.left);                
			sdepth.push(depth+1);            
		}            
		//如果遇到叶子节点，比较当前高度和上一个最大高度            
		if(temp.left == null && temp.right == null) {                  		
			max = Math.max(max, depth);            
		}        
	}           
	return max;    
}

3、广度优先遍历BFS 队列（层次遍历）

public int maxDepth(TreeNode root) {        
	if(root == null)            
		return 0;        
	int count = 0;        
	Queue<TreeNode> queue = new LinkedList<>();        
	queue.add(root);        
	while(!queue.isEmpty()) {            
		int num = queue.size();            
		for (int i = 0; i < num; i++) {                
			TreeNode temp = queue.poll();                
			if(temp.left != null) {                    
				queue.add(temp.left);                
			}                
			if(temp.right != null) {                    
				queue.add(temp.right);                
			}            
		}            
		count++;        
	}        
	return count;    
}