1.简介

二叉树的遍历主要分为深度优先遍历和广度优先遍历两大类，广度优先遍历是按层从上到下遍历(先遍历第一层，再遍历第二层...)，深度优先遍历则是每一次按树的一条路径遍历至叶子节点，然后遍历另外路径上的节点。
其中深度优先遍历又分为前序遍历、中序遍历、后序遍历。我们以下面这棵树来具体说明这些遍历之间的区别。

广度优先遍历：从左到右依次遍历每一层，即按1 2 3 4 5 6顺序遍历。

前序遍历：先遍历父节点，再遍历左子树，最后遍历右子树，即按1 2 4 5 3 6顺序遍历。

中序遍历：先遍历左子树，再遍历父节点，最后遍历右子数，即按4 2 5 1 6 3顺序遍历。

 后序遍历：先遍历左子树，再遍历右子树，最后遍历父节点，即按4 5 2 6 3 1顺序遍历。

此外，还有常数级空间的morris遍历，更为复杂，在我的另一篇博客有介绍。

2.代码实现

上面几种遍历的实现都可以分为递归和迭代两种方法。

2.1广度优先遍历

递归法

为了区分层次这里输出二维数组，使用level记录当前遍历层次。第i层的数据就放入v[i-1]中。

    void search(TreeNode* root,vector<vector<int>>&v,int level)
    {
        if(!root)return;
        if(v.size()==level)v.resize(level+1);
        v[level].emplace_back(root->val);
        search(root->left,v,level+1);
        search(root->right,v,level+1);
    }
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>>v;
        search(root,v,0);
        return v;
    }

迭代法

使用队列queue

    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>>v;
        if(!root)return v;
        queue<Node*>tmp;
        tmp.push(root);
        while(!tmp.empty())
        {
            int size=tmp.size();
            v.push_back({});
            while(size--)
            {
                Node* cur=tmp.front();
                tmp.pop();
                v.back().push_back(cur->val);
                tmp.push(cur->left);
                tmp.push(cur->right);
            }
        }
        return v;
    }

2.2前序遍历

递归法

vector<int> results;
vector<int> inorderTraversal(TreeNode* root) {
    traverse(root);
    return results;
}

void traverse(TreeNode* node){
    if(node==NULL) return;
    results.push_back(node->val);
    traverse(node->left)； 
    traverse(node->right);
}

迭代法

思路：每到一个节点 A，就应该立即访问它。因为，每棵子树都先访问其根节点。对节点的左右子树来说，也一定是先访问根。
在 A 的两棵子树中，遍历完左子树后，再遍历右子树。因此，在访问完根节点后，遍历左子树前，要将右子树压入栈。

vector<int> preorderTraversal(TreeNode* root) {
    vector<int> ans;
    if(root==NULL) return ans;
    stack<TreeNode*> s;
    s.push(root);

    while(!s.empty()){
        TreeNode* top=s.top();
        s.pop();
        ans.emplace_back(top->val);
        if(top->right) s.push(top->right);
        if(top->left) s.push(top->left);
    }
    return ans;
}

2.3中序遍历

递归法

vector<int> results;
vector<int> inorderTraversal(TreeNode* root) {
    traverse(root);
    return results;
}

void traverse(TreeNode* node){
    if(node==NULL) return;
    traverse(node->left);
    results.push_back(node->val);
    traverse(node->right);
}

迭代法

vector<int> results;
vector<int> inorderTraversal(TreeNode* root) {
    stack<TreeNode*> s;
    TreeNode* cur=root;
    while(cur || !s.empty()){
        while(cur){
            s.push(cur);
            cur=cur->left;   
        }
        TreeNode* top = s.top();
        results.push_back(top->val);
        s.pop();
        if(top->right )cur = top->right;
    }

    return results;
}

2.4后序遍历

递归法

vector<int> results;
vector<int> inorderTraversal(TreeNode* root) {
    traverse(root);
    return results;
}

void traverse(TreeNode* node){
    if(node==NULL) return;
    traverse(node->left);
    traverse(node->right);
    results.push_back(node->val);
}

迭代法

迭代法实现可以有两种方法，一种就是仿照前序遍历的方法，按中右左进行遍历，然后进行逆序，就得到了左右中的后序遍历结果。实现可以参考前序遍历，这里不再多写。

不使用反转的后序遍历比前面两种复杂，因为如果将父节点和右节点放入栈中，父节点和右节点无法区分。思路如下：

• 先遍历左节点直到左节点为null。
• 开始遍历右节点，若该右节点有左节点，优先遍历左节点。
• 使用rightchild来记录右节点是否已被遍历过。若是：则说明以该点为根的子树已被遍历，输出根节点。若否：就开始遍历右节点，回到第二步。

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        stack<TreeNode*> stk;
        TreeNode* cur = root;
        TreeNode* rightchild = NULL;
        while(cur || !stk.empty()){
            while(cur != NULL){
                stk.push(cur);
                cur = cur -> left;
            }
            cur = stk.top();
            if(!cur -> right|| rightchild == cur -> right){
                ans.push_back(cur -> val);
                stk.pop();
                rightchild = cur;
                cur = NULL;
            }
            else{
                rightchild = NULL;
                cur = cur -> right;
            }
        }
        return ans;
    }