二叉树9：二叉树的最大深度

Posted 2021-08-27 纵横千里，捭阖四方

本文主要分析两道题，LeetCode 104 如何找二叉树的最大深度

和LeetCode559：N叉树的最大深度。

1.LeetCode104 二叉树的最大深度

我们还是先看一下题意

LeetCode104：给定一颗二叉树，找出其最大深度。

二叉树的最大深度是根节点到最远叶子节点的最长路径上的节点数。例如下面这棵树的最大深度为3

1.1 递归法

 本题其实也要后序遍历(左右中)，依然是因为要通过递归函数的返回值做计算树的高度。 按照递归三部曲，来看看如何来写。

1. 确定递归函数的参数和返回值:参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类 型。

代码如下:

int getDepth(TreeNode node){}

2. 确定终止条件:如果为空节点的话，就返回0，表示高度为0。 代码如下:

if (node == null) return 0;

3. 确定单层递归的逻辑:先求它的左子树的深度，再求的右子树的深度，最后取左右深度最大的数值 再+1 (加 1是因为算上当前中间节点)就是目前节点为根节点的树的深度。

 
int leftDepth = getDepth(node.left); // 左
 int rightDepth = getDepth(node.right); // 右 
int depth = 1 + max(leftDepth, rightDepth); // 中 
return depth;

所以整体代码如下：

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

1.2 迭代法

如何用迭代的方法实现呢？首先我们引入一个队列，这是把递归程序改写成迭代程序的常用方法。初始化时我们把根节点入队两次。每次提取两个结点并比较它们的值（队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像），然后将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。 

代码如下： 

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return check(root, root);
    }

    public boolean check(TreeNode u, TreeNode v) {
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(u);
        q.offer(v);
        while (!q.isEmpty()) {
            u = q.poll();
            v = q.poll();
            if (u == null && v == null) {
                continue;
            }
            if ((u == null || v == null) || (u.val != v.val)) {
                return false;
            }

            q.offer(u.left);
            q.offer(v.right);

            q.offer(u.right);
            q.offer(v.left);
        }
        return true;
    }
}

2.LeetCode559 N叉树的最大深度

这里的要求只是将二叉树换成了N叉树。求N 叉树的最大深度，例如下面N叉树的最大深度是3

 如果面试时直接做这个题估计很懵逼，但是练习过上面这个题了，就没什么难度了。不同点就在于N叉树怎么遍历。

我们先看N叉树的定义：

class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};

 所以遍历的时候加一个for循环，每个节点分别调用递归，如果在所有递归前处理父节点就是前序。如果所有子节点都访问完后才处理，就是后序。中间嘛，都算中序吧。

我们就看一下递归的实现吧：

class Solution {
  public int maxDepth(Node root) {
    if (root == null) {
      return 0;
    } else if (root.children.isEmpty()) {
      return 1;  
    } else {
      List<Integer> heights = new LinkedList<>();
      for (Node item : root.children) {
        heights.add(maxDepth(item)); 
      }
      return Collections.max(heights) + 1;
    }
  }
}