辛星Java树算法教程第六篇:二叉树的深度(递归与非递归，共三种思路)

所谓二叉树的深度，就是树的高度。如果只有一个根节点，那么树的深度就是1。如果左子树和右子树都非空，那么就是左子树和右子树的深度的最大值，再加上1，即根节点本身。

一般来说，求解树的深度有三个大的思路，这里分别介绍一下吧:
(1).采用递归的思路，分别求出左子树的深度和右子树的深度。
(2).采用非递归的思路，这里可以使用深度遍历，这里我们可以用后序遍历。因为后序遍历的时候，左子树和右子树的深度是已知的，每次当需要遍历根节点的时候，深度加1。
(3).采用非递归的思路，这里依托分层遍历，每到一个新的一层，深度就加1。

既然明确了思路，我们就来给出具体的代码实现吧。
第一种就是递归的思路，这一种比较简单，只需要把握好定义即可，我们来看一下具体的代码实现吧:

package com.mengzhidu.teach.algorithm.tree.demo.basic;

import com.mengzhidu.teach.algorithm.tree.demo.TreeNode;
import com.mengzhidu.teach.algorithm.tree.demo.TreeNodeHelper;

/**
 * 求一颗二叉树的深度
 * 这里使用递归的方式来实现，这种思路比较简单，它只需要比较左右子树的实现即可
 */
public class DepthDemo1 {

    public static void main(String[] args) {
        TreeNode root = TreeNodeHelper.getTreeNode();
        int depth = getDepth(root);
        System.out.println("数的深度为:" + depth);
    }

    private static int getDepth(TreeNode node) {
        if (node == null) {
            return 0;
        }

        int leftDepth = getDepth(node.getLeft());
        int rightDepth = getDepth(node.getRight());
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }
}

第二种，我们采用后序遍历的方式，因为后序遍历的方式有很多，我们来给出一种实现即可，因为前面有介绍后序遍历，这里我们也给出一种代码吧:

package com.mengzhidu.teach.algorithm.tree.demo.basic;

import com.mengzhidu.teach.algorithm.tree.demo.TreeNode;
import com.mengzhidu.teach.algorithm.tree.demo.TreeNodeHelper;

import java.util.Stack;

/**
 * 树的深度的非递归实现
 * 这里可以利用后序遍历，每次遍历根节点的时候就深度加1
 * 这个时候就可以计算树的深度，其实所有的后序遍历都可以用来计算树的深度
 * 这里仅以一个后序遍历为例，这里使用压两次的方式来计算
 */
public class DepthDemo2 {

    public static void main(String[] args) {
        TreeNode node = TreeNodeHelper.getTreeNode();
        Stack<TreeNode> stack = new Stack<>();
        stack.push(node);
        stack.push(node);
        int depth = 1;

        while (!stack.isEmpty()) {
            node = stack.pop();
            if (!stack.isEmpty() && node != stack.peek()) {
                if (node.getLeft() != null) {
                    stack.push(node.getLeft());
                    stack.push(node.getLeft());
                }
                if (node.getRight() != null) {
                    stack.push(node.getRight());
                    stack.push(node.getRight());
                }
            } else {
                depth ++;
            }
        }

        System.out.println("栈的深度是:" + depth);
    }
}

第三种方式就是使用分层遍历的方式，这里我们只需要知道如何来定位每一层即可，这里我们可以使用记录每一层的最左节点的方式，也可以采用记录每一层的节点个数的方式。
我们来给出代码的实现方式吧:

package com.mengzhidu.teach.algorithm.tree.demo.basic;

import com.mengzhidu.teach.algorithm.tree.demo.TreeNode;
import com.mengzhidu.teach.algorithm.tree.demo.TreeNodeHelper;

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * 用非递归的方式来计算树的深度
 * 这里采用的是分层遍历的方式，每一层都加1
 * 确定在哪一层的方式有很多，这里我们采用记录每一层最左节点的方式
 */
public class DepthDemo3 {

    public static void main(String[] args) {
        TreeNode root = TreeNodeHelper.getTreeNode();
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        int depth = 1;

        TreeNode left = root.getLeft();
        while (queue.size() > 0) {
            TreeNode tmp = queue.poll();
            if (tmp == left) {
                depth ++;
                left = null;
            }
            if (tmp.getLeft() != null && left == null) {
                left = tmp.getLeft();
            }
            if (tmp.getRight() != null && left == null) {
                left = tmp.getRight();
            }
            if (tmp.getLeft() != null) {
                queue.add(tmp.getLeft());
            }
            if (tmp.getRight() != null) {
                queue.add(tmp.getRight());
            }
        }

        System.out.println("深度为:" + depth);
    }
}

对于求解树的深度，我们就介绍到这里啦。