一、二叉树的先序、中序、后序遍历

先序、中序和后续遍历指的是二叉树根节点的输出顺序，左右子树也遵循该规则
先序表示先输出根节点，也就是：根左右的顺序，左右子树也遵循该规则
中序表示根节点输出的顺序是中间（也就是第二位），也就是：左根右的顺序
后序表示根节点输出的顺序是最后，也就是：左右根的顺序
下图例子分别是三种遍历的结果：

二、递归遍历

本节介绍三种遍历方式的递归实现。
题目参考Leetcode：

1.先序遍历 - 递归实现

递归的实现首先要明确出口，也就是root为空时，然后确定访问的顺序
如：先序遍历是：根左右
代码如下：
依次类推，中序和后序的递归实现只需要调整Traversal函数中的语句顺序即可

c++代码如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        Traversal(root, res);
        return res;
    }
    void Traversal(TreeNode* root, vector<int> &res) {
        if(root) {
            res.push_back(root -> val); // 根
            Traversal(root -> left, res); // 左
            Traversal(root -> right, res); // 右
        }
    }
};

2.中序遍历 - 递归实现

c++代码如下：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        Traversal(root, res);
        return res;
    }
     void Traversal(TreeNode* root, vector<int> &res) {
        if(root) {
            Traversal(root -> left, res); // 左
            res.push_back(root -> val); // 根
            Traversal(root -> right, res); // 右
        }
    }
};

3.后序遍历 - 递归实现

c++代码如下：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        Traversal(root, res);
        return res;
    }
    void Traversal(TreeNode* root, vector<int> &res) {
        if(root) {
            Traversal(root -> left, res); // 左
            Traversal(root -> right, res); // 根
            res.push_back(root -> val); // 右
        }
    }
};

三、迭代遍历

本节介绍三种遍历方式的迭代实现。

题目参考Leetcode：

递归的实现使用到的栈，每一次的递归调用会把函数的局部变量等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，这样就可以实现从底向上一层一层的进行返回了。
因此，在迭代遍历中，可以使用栈（stack）实现前中后序遍历。

1.先序遍历 - 迭代实现

如果root不空，将根节点入栈
访问栈顶元素，然后弹出，如果右节点不空，则入栈; 如果左边节点不空，入栈
直到栈为空，重复2步骤

c++代码如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if(root) st.push(root);
        
        while(! st.empty()) {
            TreeNode* p = st.top();
            res.push_back(p -> val);
            st.pop();
            if(p -> right) st.push(p -> right);
            if(p -> left) st.push(p -> left);
        }
        return res;
    }
};

2.中序遍历 - 迭代实现

如果root不空，或者root有效，则一直向左遍历，直到null为止
访问栈顶元素，然后弹出，如果右节点不空，则入栈
再次循环访问子树，重复1步骤

c++代码如下：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        // 左 中 右
        vector<int> res;
        stack<TreeNode*> st;
        
        TreeNode* p = root;
        while(! st.empty() || p) {
            if(p) {
                st.push(p);
                p = p -> left;
            }
            else {
                TreeNode* t = st.top();
                res.push_back(t -> val);
                st.pop();
                if(t) p = t -> right;
            }
        }
        return res;
    }
};

3.后序遍历 - 迭代实现

后序遍历和先序遍历差不多，先序遍历是：根左右，后序遍历是：左右根
只需要调整先序遍历的部分语句，使得输出为 根右左，然后将结果反转即为 左右根

c++代码如下：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        // 左 右 中
        vector<int> res;
        stack<TreeNode*> st;
        if(root) st.push(root); 
        while(! st.empty()){
            TreeNode* t = st.top();
            res.push_back(t -> val);
            st.pop();
            if(t -> left) st.push(t -> left);
            if(t -> right) st.push(t -> right);
        }
        reverse(res.begin(), res.end()); // 结果反转
        return res;
    }
};