牛客网：二叉树的遍历（前中后序）

目录

1.前序遍历

2.后序遍历

3.中序遍历

---

分别用递归和栈的方法做一遍

1.前序遍历

递归

由于访问的顺序是根左右，每个节点都可以抽象成这样的访问模式，因此适合递归，下面是代码：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> preorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        preOrder(res, root);
        return res;
    }
    void preOrder(vector<int> &res, TreeNode *root){
        if(root==NULL) return;
        res.push_back(root->val);
        preOrder(res, root->left);
        preOrder(res, root->right);
    }
};

除此之外，我们用前序的时候，是先从根到最左下方，然后开始再反向取出，依次看有无右节点，这样是不是很像栈，因此可以用一个栈来模拟，具体流程如下所示：

1.将根节点压入栈中

2.从栈中取出一个节点并将值放入res中

3.若有右节点，将右节点压入栈中

4.若有左节点，将左节点压入栈中

5.若栈不为空，转2

一点说明：这里由于是前序遍历，所以要把右边的节点先压在栈底

代码如下所示：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> preorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode *> s;
        s.push(root);
        while(!s.empty()){
            TreeNode* node=s.top();
            s.pop();
            res.push_back(node->val);
            if(node->right){
                s.push(node->right);
            }
            if(node->left){
                s.push(node->left);
            }
        }
        return res;
    }
};

2.后序遍历

递归：和前序大同小异，代码如下所示：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> postorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        postOrder(res, root);
        return res;
    }
    void postOrder(vector<int> &res, TreeNode* root){
        if(root==NULL) return;
        postOrder(res, root->left);
        postOrder(res, root->right);
        res.push_back(root->val);
    }
};

栈：

这里很巧妙的地方在于用一个pre指针记录之前成功访问的节点。

对于从栈中取出的一个节点：

1.如果右子树为空或者右子树由pre指向（说明访问右子树结束）

        那么放入res，更新pre

2.否则，将这个节点重新压入栈中（因为还不能处理），之后继续处理其右子树

代码如下所示：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> postorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode* pre=NULL;
        while(root!=NULL || !s.empty()){
            while(root!=NULL){
                s.push(root);
                root=root->left;
            }
            TreeNode* node=s.top();
            s.pop();
            if(node->right==NULL || node->right==pre){
                res.push_back(node->val);
                pre=node;
            }else{
                s.push(node);
                root=node->right;
            }
        }
        return res;
    }
};

3.中序遍历

递归：

大同小异，代码如下所示：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        inOrder(res, root);
        return res;
    }
    void inOrder(vector<int> &res, TreeNode* root){
        if(root==NULL) return;
        inOrder(res, root->left);
        res.push_back(root->val);
        inOrder(res, root->right);
    }
};

栈：

这里用栈需要一次性走到底，走到最左下方，然后从栈中取出一个节点时，我们默认这个节点的左子树和本身是遍历完的，之后再处理其右子树，代码如下所示：

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return int整型vector
     */
    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> s;
        while(root!=NULL || !s.empty()){
            while(root!=NULL){
                s.push(root);
                root=root->left;
            }
            TreeNode *node=s.top();
            s.pop();
            res.push_back(node->val);
            root=node->right;
        }
        
        return res;
    }
};