leetcode+二叉树+二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

TreeNode的代码链接

代码实现链接

方法一：递归深度优先遍历

• 时间复杂度：O(N)每个节点访问且仅访问一次
• 空间复杂度：O(logN - N)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

package BinaryTree;
import java.lang.Math;

public class Solution {
	public int maxDepth0(TreeNode root) {
		if(root==null)
			return 0;
		if(root.left==null)
			return maxDepth0(root.right)+1;
		if(root.right==null)
			return maxDepth0(root.left)+1;
		return Math.max(maxDepth0(root.left),maxDepth0(root.right))+1;
	}
	
	public static void main(String[] args) {
		TreeNode root=new TreeNode(3);
		TreeNode layer21=new TreeNode(9);
		TreeNode layer22=new TreeNode(20);
		TreeNode layer33=new TreeNode(15);
		TreeNode layer34=new TreeNode(7);
		root.left=layer21;
		root.right=layer22;
		layer22.left=layer33;
		layer22.right=layer34;
		
		Solution main=new Solution();
		int result=main.maxDepth0(root);
		System.out.print(result);
	}
}

方法二：迭代深度优先遍历

思路：利用栈，深度优先遍历访问每个节点，同时每次访问时更新

	//迭代的深度优先遍历
	public int maxDepth1(TreeNode root) {
		if (root==null)
			return 0;
		
		//从包含根结点且相应深度为1的栈开始
		Stack<TreeNode> stack=new Stack<>();
		Stack<Integer> value=new Stack<>();
		stack.push(root);
		value.push(1);
		
		//深度优先遍历每个结点，同时每次访问更新最大深度
		int depth=0;
		while(!stack.isEmpty()) {
			//将当前结点弹出栈
			TreeNode node=stack.pop();
			Integer temp=value.pop();
			//更新深度
			depth=Math.max(temp, depth);
			//推入子节点
			if(node.left!=null) {
				stack.push(node.left);
				value.push(temp+1);
			}
			if(node.right!=null) {
				stack.push(node.right);
				value.push(temp+1);
			}
		}
		return depth;
	}

方法三：迭代广度优先遍历

思路：逐层遍历，每层对深度进行更新

• 将t层的节点从左到右入队，统计t层节点数
• t层节点从左到右出队，将其孩子节点入队
• 对深度进行更新

	//迭代的广度优先遍历
	public int maxDepth2(TreeNode root) {
		if(root==null) return 0;
		
		int depth=0;
		Queue<TreeNode> queue = new LinkedList<TreeNode>();
		queue.offer(root);
		while(!queue.isEmpty()) {
			depth++;
			int size=queue.size();//注意，这里必须先拿到size(上一层的node个数)！
			for(int i=0;i<size;i++) {
				TreeNode node=queue.poll();//节点出队，并记录
				//System.out.print(size+" ");
				//System.out.print(node.val+" ");
				//System.out.println(depth);
				if(node.left!=null)
					queue.offer(node.left);
				if(node.right!=null)
					queue.offer(node.right);
			}
		}
		return depth;
	}