力扣二叉树的前序中序后序遍历总结

二叉树的前中后序遍历，需要我们牢牢掌握。
力扣有题目，我们借这三个题目牢牢弄清楚关于整个二叉树的前中后序遍历。

144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历

首先我们要清楚，所谓前序，中序和后序是三种不同的二叉树的遍历方式。

前序

前序就是先遍历根节点再遍历左节点（有子树遍历子树）最后遍历右节点（有子树遍历子树）
口诀即为：根左右。
重点在于写代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    void preorder(TreeNode* root,vector<int>& ans)
    {
        if(root==nullptr)
        {
           
            return ;
        }
        else
        {
            ans.push_back(root->val);
            preorder(root->left,ans);
            preorder(root->right,ans);
        
        }

    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ans;
        //ans.push_back(root->val);
       preorder(root,ans);
        return ans;
    }
};

写代码的时候要注意用递归的写法来写，按照根左右的顺序递归调用。
接着是中序

中序

中序就是左根右，和前序的解释一样，无非是顺序不一样。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
     void inorder(TreeNode* root,vector<int>& ans)
     {
        if(root==nullptr)
        {
           return;
        }
        else
        {
           inorder(root->left,ans);
           ans.push_back(root->val);
           inorder(root->right,ans);
        }
     }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        inorder(root,ans);
        return ans;
    }
};

后序

后序就是左右根

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
   void postorder(TreeNode* root,vector<int>& ans)
   {
        if(root==nullptr)
        {
            return;
        }
        else
        {
            postorder(root->left,ans);
            postorder(root->right,ans);
            ans.push_back(root->val);
        }
   }
    vector<int> postorderTraversal(TreeNode* root) {
        //左右根
        vector<int> ans;
        postorder(root,ans);
        return ans;
    }
};

写代码也是严格的按照遍历顺序的方式用递归的写法写的。
除此之外也可以用栈来写，但递归的代码都比较简练，一般都用递归来写。
时间复杂度为O（n)n为节点数