樹的遍歷方式一般來說兩類，深度優先搜尋（DFS）和廣度優先搜尋(BFS)

• DFS:先序遍歷、中序遍歷、後序遍歷
• BFS:層序遍歷

先序遍歷

輸出順序： 當前節點 左子樹 右子樹

中序遍歷

輸出順序： 左子樹 當前節點右子樹

後序遍歷

輸出順序： 左子樹 右子樹當前節點

樹的後序遍歷/深度優先搜尋常利用 遞迴 或 棧 實現。

舉個栗子，判斷樹是不是平衡樹：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof/

    int recur(TreeNode* root){
        if(root == NULL) return 0;
        
 
int left = recur(root->left);
        if(left==-1) return -1;
        int right = recur(root->right);
        if(right==-1) return -1;
        if(abs(left-right)<=1){
            return max(left,right)+1;
        }else{
            return -1;
        }
    }
    bool isBalanced(TreeNode* root) {
        
 
//後序遍歷+ 減枝
        return recur(root) != -1;
    }

層序遍歷（BFS）

樹的層序遍歷 / 廣度優先搜尋往往利用佇列實現

思路一次把樹的一層內有效的節點加入佇列中！

舉個例子：

獲取樹的深度，用DFS可以簡單化程式碼，很快啊，當然還可以用BFS：

int maxDepth(TreeNode* root) {

        int res = 0;
        if (!root) {
            return 0;
        }

        queue<TreeNode*> q_save_one_layer_node;
        q_save_one_layer_node.push(root);
        
 
while (q_save_one_layer_node.size()) {
            vector<int> tmp_val;
            for (int i = q_save_one_layer_node.size(); i > 0; i--) {   
                TreeNode* node = q_save_one_layer_node.front();
                q_save_one_layer_node.pop();
                tmp_val.push_back(node->val);
                if (node->left != NULL) {
                    q_save_one_layer_node.push(node->left);
                }
                if (node->right) {
                    q_save_one_layer_node.push(node->right);
                }
            }

            res+=1;
        }

        return res;
}

def maxDepth(self, root: TreeNode) -> int:
    
    #  DFS 後序遍歷 
    #if not root: return 0
    #return max(self.maxDepth(root.left),self.maxDepth(root.right))+1



    # BFS 
    if not root:return 0
    queue,res = [root],0
    while queue:
        tmp = []  #因為要把一層的佇列對給加入佇列中遍歷 所以用佇列 
        for node in queue: # 上一層出隊
            if node.left: tmp.append(node.left) #下一層入隊
            if node.right: tmp.append(node.right) #下一層入隊
        queue = tmp #上一層出隊下一層入隊
        res+=1
    return res