【Java】【JS】LeetCode - 递归 - 迭代 - #104 二叉树的最大深度

心若向阳，无惧悲伤。 力扣力扣：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

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

function TreeNode(val) {
     this.val = val;
     this.left = this.right = null;
}

 #104 二叉树的最大深度

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

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

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

方法一：递归

递归计算树的左右子树的高度。树的高度=max（左子树高度，右子树高度）+1

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

方法二：迭代

BFS层序遍历+队列实现

记录二叉树的层数，队列中放入一层的节点，依次拿出，再放入下一层全部节点。

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int maxheight = 0;
        while(queue.size()>0){
            maxheight++;
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.removeFirst();
                if(node.left!=null){
                    queue.add(node.left);
                }
                if(node.right!=null){
                    queue.add(node.right);
                }
            }
        }
        return maxheight;
    }
}

DFS前序遍历+栈实现

// java
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        LinkedList<TreeNode> stack = new LinkedList<>();
        stack.push(new Pair<>(root, 1));
        int maxheight = 0;
        // DFS 每个节点记录深度
        while(!stack.isEmpty()){
            Pair<TreeNode, Integer> pair = stack.pop();
            TreeNode node = pair.first;
            // 更新高度
            maxheight = Math.max(maxheight, pair.second);
            int curheight = pair.second;
            // 子节点入栈，深度加一
            if(node.right!=null){
                stack.push(new Pair<>(node.right, curheight+1));
            }
            if(node.left!=null){
                stack.push(new Pair<>(node.left, curheight+1));
            }
        }

        return maxheight;
    }
}

/* javascript
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function(root) {
    var tmpStack = [
        {"key":root,"val":1}
    ];
    var depth = 0;
    while(tmpStack.length != 0){
        var currObj = tmpStack.pop();
        var currNode = currObj.key;
        if(currNode != null){
            var currNode_depth = currObj.val;
            depth = Math.max(depth,currNode_depth);
            if(currNode.left != null){
                tmpStack.push({"key":currNode.left,"val":currNode_depth + 1});
            }
            if(currNode.right != null){
                tmpStack.push({"key":currNode.right,"val":currNode_depth + 1});
            }
        }
    }
    return depth;
};