二叉树的最大/最小深度

一、二叉树的深度是什么？

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数，如果是边的条数，深度从0开始；如果是节点个数，深度从1开始。一般要先遍历根节点，故常采用前序遍历方法求深度。

二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或节点数。一般要遍历到叶子节点，故常采用后序遍历方法求深度。

根节点的高度就是二叉树的最大深度，所以也可以用前序遍历的方法求二叉树的最大深度（即根节点的高度）。

---

二、求二叉树的最大深度

递归

//后序遍历
int getDepth(Treenode* node) {
        if (node == NULL) return 0;
        int leftdepth = getDepth(node->left);       // 左
        int rightdepth = getDepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }

int maxDepth(Treenode* root) {
        return getDepth(root);
    }

//前序遍历
int result;
void getDepth(treenode* node, int depth) {
     result = max(depth, result); // 中

     if (node->left == NULL && node->right == NULL) return ;

     if (node->left) { // 左
         getDepth(node->left, depth + 1);
     }

     if (node->right) { // 右
         getDepth(node->right, depth + 1);
     }
     return ;
    }

int maxDepth(treenode* root) {
    result = 0;
    if (root == 0) return result;
    getDepth(root, 1);
    return result;
    }

迭代

//层序遍历
int maxDepth(Treenode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<Treenode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; 
            for (int i = 0; i < size; i++) {
                treenode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }

---

三、二叉树的最小深度

递归

//后序遍历
int getDepth(TreeNode* node) {
    if (node == NULL) return 0;
    int leftDepth = getDepth(node->left);           // 左
    int rightDepth = getDepth(node->right);         // 右
                                                    // 中

    //只有当这个节点左右孩子都为空时，该节点才是叶子节点
    // 当一个左子树为空，右不为空，这时并不是最低点
    if (node->left == NULL && node->right != NULL) { 
        return 1 + rightDepth;
    }   
    // 当一个右子树为空，左不为空，这时并不是最低点
    if (node->left != NULL && node->right == NULL) { 
        return 1 + leftDepth;
    }
    return 1 + min(leftDepth, rightDepth);
}

int minDepth(TreeNode* root) {
    int result = getDepth(root);
    return result;
}

//前序遍历
int result;
void getDepth(TreeNode* node, int depth) {
   if (node->left == NULL && node->right == NULL) {
        result = min(depth, result);  
        return;
    }
    // 中 只不过中没有处理的逻辑
    if (node->left) { // 左
        getDepth(node->left, depth + 1);
    }
    if (node->right) { // 右
        getDepth(node->right, depth + 1);
    }
    return ;
}

int minDepth(TreeNode* root) {
    if (root == NULL) return 0;
    result = INT_MAX;
    getDepth(root, 1);
    return result;
}

迭代

//迭代法
int minDepth(TreeNode* root) {
    if (root == NULL) return 0;
    int depth = 0;
    queue<TreeNode*> que;
    que.push(root);
    while(!que.empty()) {
        int size = que.size();
        depth++; // 记录最小深度
        for (int i = 0; i < size; i++) {
            TreeNode* node = que.front();
            que.pop();
            if (node->left) que.push(node->left);
            if (node->right) que.push(node->right);
            if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                return depth;
            }
        }
    }
    return depth;
}