先看Leetcode104：Maximum Depth of Binary Tree，求二叉樹最大深度。

有兩種解法，基於DFS（深度優先搜尋）思想的方法使用遞迴計算：

class Solution {
public:
    int maxDepth(TreeNode *root) {
        if(root == nullptr)
            return 0;
        int lef = maxDepth(root->left);
        int rig = maxDepth(root->right);
        
        return (lef > rig ? lef : rig) + 1;
    }
};
 

執行時間：10ms，佔用記憶體：864k

基於BFS（寬度/廣度優先搜尋）思想的方法使用非遞迴計算，採用層序遍歷，需要引入佇列：

class Solution {
public:
    int maxDepth(TreeNode *root) {
        if(root == nullptr)
            return 0;
        queue <TreeNode *> que;    // 將二叉樹中的元素逐層新增到佇列中，層序遍歷到最後一層
        int nCount = 1;    // 每一層中節點個數，根節點這一層只有1個節點故初始化為1
        int nDepth = 0;    // 記錄深度
        que.push(root);
        while(!que.empty()){
            TreeNode * pTemp = que.front();    // 取出隊首元素
            que.pop();    // 彈出隊首元素
            --nCount;    // 逐個元素彈出
            
            if(pTemp->left)    // 將下一層的節點新增到佇列中
                que.push(pTemp->left);
            if(pTemp->right)
                que.push(pTemp->right);
            
            if(nCount == 0){    // 這一層節點已經遍歷完
                nCount = que.size();    // nCount是下一層節點數目
                ++nDepth; // 深度+1
            }
        }
        return nDepth;
        
    }
};
 

執行時間：8ms，佔用記憶體：884k

求最小二叉樹深度跟求最大二叉樹深度類似，不同點在於求最小深度時需要判斷左右節點，因為當一個節點只有左子樹或右子樹時，不能直接取其左右子樹中最小的深度，因為那個深度是0（因為只有一個子樹），樹的深度必須要到葉子節點才行（既沒有左子樹也沒有右子樹）。而求最大深度的時候，因為每一個子樹取的都是最大深度，就不會有非葉子節點判斷錯誤的問題了。

1.基於DFS：

class Solution {
public:
    int run(TreeNode *root) {
        if(root == nullptr)
            return 0;
        if(root->left == nullptr)
            return run(root->right) + 1;
        if(root->right == nullptr)
            return run(root->left) + 1;
        return min(run(root->left),run(root->right)) + 1;
    }
};
 

執行時間：12ms，佔用記憶體：848k

2.基於BFS：

class Solution {
public:
    int run(TreeNode *root) {
        if(root == NULL)
            return false;
        queue<TreeNode *> que;
        TreeNode *last, *cur;
        int level = 1, size = 0;
        last = cur = root;
        que.push(root);
        while(!que.empty()){
            cur = que.front();
            que.pop();
            size = que.size();
            if(cur->left)
                que.push(cur->left);
            if(cur->right)
                que.push(cur->right);
            if(que.size() == size)  //迴圈終止條件
                break;
            if(last == cur){
                level++;
                if(que.size() != 0)
                    last = que.back();
            }
        }
        return level;
    }
}