树的遍历

树的遍历方式一般来说两类，深度优先搜索（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