leetcode [Maximum Depth of Binary Tree]

//DFS递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    //The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node
    //说明maxDepth计算的是最长路径上的结点个数
    //设计递归算法时只用考虑到最开始的一层，然后找到递归出口即可
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;//递归出口
        else return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
    }
}

一种未完成的DFS迭代思路：

class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;
	TreeNode(int x) { val = x; }
}

class Solution {
	//解法二（非递归算法）：采用深度优先遍历的思想，用maxDepth来存放最终的maxDepth，
	//用thisMax来与maxDepth比较，maxDepth = max{maxDepth, thisMax}，
	//thisMax的计算方法，压入一个子结点，thisMax++,弹出一个结点thisMax--;
	//同时需要一个数来保存上一层的数，因为弹出后压入右侧结点时返回时弹出的结点已经弹出，控制不了thisMax--了
	//这种方法只能计算出maxDepth，但无法算出具体的最长路径上的结点，
	//如果要求最长路径上的结点，先求出maxDepth，在深度优先遍历时比较thisMax与maxDepth，
	//若相等，则结束，则求出从左到右第一条最长路径上的结点
	
	//树的深度优先遍历，先在栈中压入根结点，根结点的左子结点，左子结点的左子结点...直到左子结点为空
	//然后弹栈，判断右子结点是否为空，若不为空，重复上一行；若为空，继续弹栈
	
    public int maxDepth(TreeNode root) {
    	if(root == null) return 0;
    	Stack<TreeNode> stack = new Stack<>();
    	int maxDepth = 0;
    	int thisMax = 0;
    	TreeNode temp = root;
    	while(temp != null){
    		stack.push(temp);
    		thisMax++;//压栈thisMax++
    		if(thisMax > maxDepth) maxDepth = thisMax;
    		temp = temp.left;
    		while(!stack.isEmpty()){
    			temp = stack.pop();
    			thisMax--;//弹栈thisMax--
    			if(temp.right != null){//***
    				thisMax++;//当弹出结点的右子结点不为空时，thisMax++,因为之前递减了，这里要加回来
    				temp = temp.right;
    				break;//当弹出结点的右子结点不为空时，重复最外层循环
    			}
    			//这里有一个问题，右子结点重复完了后跳回到上一层时thisMax不好控制，用一个count来记录上一层也不好使
    			//所以当"***"时重复只能通过递归完成？
    		}
    	}
    	return maxDepth;
    }
}

DFS迭代：

class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;
	TreeNode(int x) { val = x; }
}

class Solution {
	//解法二（非递归算法）：采用深度优先遍历的思想，用maxDepth来存放最终的maxDepth，
	//用thisMax来与maxDepth比较，maxDepth = max{maxDepth, thisMax}，
	//thisMax的计算方法，压入一个子结点，thisMax++,弹出一个结点thisMax--;
	//同时需要一个数来保存上一层的数，因为弹出后压入右侧结点时返回时弹出的结点已经弹出，控制不了thisMax--了
	//这种方法只能计算出maxDepth，但无法算出具体的最长路径上的结点，
	//如果要求最长路径上的结点，先求出maxDepth，在深度优先遍历时比较thisMax与maxDepth，
	//若相等，则结束，则求出从左到右第一条最长路径上的结点
	
	//树的深度优先遍历，先在栈中压入根结点，根结点的左子结点，左子结点的左子结点...直到左子结点为空
	//然后弹栈，判断右子结点是否为空，若不为空，重复上一行；若为空，继续弹栈
	
    public int maxDepth(TreeNode root) {
    	//DFS迭代(有点BFS的意思)
    	//解决上面的层数不好控制时，用一个栈来存放从根结点到每个结点的路径长度，实时跟踪对应存放该结点的栈
    	//stack压入Node，则value也压入从根结点到Node的路径长度，stack弹出时value也弹出
    	if(root == null) return 0;
    	Stack<TreeNode> stack = new Stack<>();
    	Stack<Integer> value = new Stack<>();
    	stack.push(root);
    	value.push(1);//stack与value同步压入
    	int maxDepth = 0;
    	while(!stack.isEmpty()){
    		TreeNode node = stack.pop();
    		int temp = value.pop();//stack与value同步弹出
    		maxDepth = Math.max(temp, maxDepth);
    		if(node.right != null){//先压入右结点更像是DFS
    			stack.push(node.right);
    			value.push(temp + 1);
    		}
    		if(node.left != null){
    			stack.push(node.left);
    			value.push(temp + 1);
    		}
    	}
    	return maxDepth;
    }
}

BFS迭代：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int maxDepth(TreeNode root) {
    	//BFS迭代（一层一层的往下找长度，层次遍历是用Queue存）
    	if(root == null) return 0;
    	Queue<TreeNode> queue = new LinkedList<>();
    	TreeNode temp = null;
    	int maxDepth = 0;
    	queue.add(root);
    	while(!queue.isEmpty()){
    		maxDepth++;//只要queue非空，说明该层有元素，则maxDepth++
    		for(int i = 0, n = queue.size(); i < n; i++){//用queue.size要先存起来，因为每次弹了后queue大小会减小
    			//将每一层的队列里的结点弹出来，再将弹出的每一个结点的下一层放入队列中
    			temp = queue.poll();
    			if(temp.left != null)
    				queue.add(temp.left);
    			if(temp.right != null)
    				queue.add(temp.right);
    		}
    	}
    	return maxDepth;
    }
}