编程导航算法村第八关 | 树的深度优先遍历（二）

编程导航算法村第八关 | 树的深度优先遍历（二）

最大深度问题

首先看一下104题最大深度:给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。

• 思路：
  • 采用深度优先遍历，分别遍历左右子树，比较左右子树的深度，返回最大值

public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int result = dfs(root, 0);
        return result;
    }

    int dfs(TreeNode root, int deep) {
        if (root == null) {
            return deep;
        }
        int left = dfs(root.left, deep + 1);
        int right = dfs(root.right, deep + 1);

        return left >= right ? left : right;
    }

判断平衡树

LeetCode110 判断平衡二叉树：给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

• 思路：每个节点都进行判断，获取待判断元素的左子树的深度，获取带判断元素右子树的深度，判断差值是否小于1；接着判断左节点是否是高度平衡的二叉树，再判断右子树是不是高度平衡的二叉树

 public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        int left = dfs(root.left, 0);
        int right = dfs(root.right, 0);
        if (Math.abs(left - right) > 1) {
            return false;
        }

        Boolean lb = isBalanced(root.left);
        Boolean rb = isBalanced(root.right);

        return lb && rb;

//        final int dfs = dfs(root, 0);
//        if (dfs <= 1) {
//            return true;
//        } else {
//            return false;
//        }
    }

    int dfs(TreeNode root, int deep) {
        if (root == null) {
            return deep;
        }
//        得到左右字数的深度
        int left = dfs(root.left, deep + 1);
        int right = dfs(root.right, deep + 1);
//      左右字数的差值

        return left >= right ? left : right;
    }

最小深度

既然有最大深度，那是否有最小深度呢？LeetCode111就是：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量

• 思路：
  • 使用深度优先遍历，得到左右子树的高度
  • 有三种情况：根节点两端都有子树
    • 返回高度的中的最小值
  • 没有左子树
    • 返回右子树的高度
  • 没有右子树
    • 返回左子树的高度

 public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
//        if (root.left == null || root.right == null) {
//            return 1;
//        }
        final int dfs = dfs(root, 0);
        return dfs;
    }

    int dfs(TreeNode root, int deep) {
        if (root == null) {
            return deep;
        }
        int left = dfs(root.left, deep + 1);

        int right = dfs(root.right, deep + 1);

        if (root.left == null && root.right != null) {
            return right;
        }
        if (root.left != null && root.right == null) {
            return left;
        }
        return left <= right ? left : right;
    }

N叉树的最大深度

如果将二叉树换成N叉树又该怎么做呢？这就是LeetCode559.给定一个 N 叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔

 public int maxDepth(Node root) {
        if (root == null) {
            return 0;
        }

        return dfs(root);

    }

    int dfs(Node root) {
        if (root == null) {
            return 0;
        } else if (root.children.isEmpty()) {
            return 1;
        } else {
            final ArrayList<Integer> integers = new ArrayList<>();
            for (Node node : root.children) {
                int max = dfs(node);
                integers.add(max);
            }
            return Collections.max(integers) +1;
        }

    }

• 解法二
  • 思路：使用深度优先遍历

    public int maxDepth(Node root) {
        if (root == null) {
            return 0;
        }
        return dfs(root, 0);

    }

    int dfs(Node root, int deep) {
        if (root == null) {
            return deep;
        } else if (root.children.isEmpty()) {
            return deep + 1;
        } else {
             ArrayList<Integer> integers = new ArrayList<>();
            for (Node node : root.children) {
                int max = dfs(node, deep + 1);
                integers.add(max);
            }
            return Collections.max(integers);
        }

    }