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

94.二叉树的中序遍历

• 递归法的代码较为简单

class Solution {
public:
    void inOrder(TreeNode*root,vector<int> &res){
        if(root== nullptr) return;
        inOrder(root->left,res);
        res.push_back(root->val);
        inOrder(root->right,res);
    }
    
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inOrder(root,res);
        return res;
    }
};

• 迭代法
  实现需要利用栈来模拟元素的访问与处理，由于中序遍历的特殊性，需要沿左分支下行先访问结点（将结点入栈），再处理结点（出栈时再处理）

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

144.二叉树的前序遍历

• 递归法

class Solution {
public:
    void inOrder(TreeNode*root,vector<int> &res){
        if(root== nullptr) return;
        res.push_back(root->val);
        inOrder(root->left,res);
        inOrder(root->right,res);
    }
    
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inOrder(root,res);
        return res;
    }
};

• 迭代法
  先序遍历可以在访问的时候就处理结点

class Solution {//中左右
public:
    vector<int> preorderTraversal(TreeNode *root) {
        stack<TreeNode*> s;
        vector<int> res;
        if(root== nullptr)return res;
        s.push(root);
        while (!s.empty()){
            TreeNode*node=s.top();
            s.pop();
            if(node!= nullptr)res.push_back(node->val);
            else continue;
            s.push(node->right);
            s.push(node->left);
        }
        return res;
    }
};

145.二叉树的后序遍历

• 递归法

class Solution {
public:
    void preOrder(TreeNode* root,vector<int> &res){
        if(root== nullptr) return;
        preOrder(root->left,res);
        preOrder(root->right,res);
        res.push_back(root->val);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        preOrder(root,res);
        return res;
    }
};

• 迭代法
  后序需要把中序的遍历过程改一下，由于是左右中的顺序，所以和中序不同的是在处理结点之前需要确定右孩子是否访问过或不存在

class Solution {//中左右
                //左右中：reverse.中右左
public:
    vector<int> postorderTraversal(TreeNode* root){
        stack<TreeNode*> s;
        vector<int> res;
        if(root== nullptr)return res;
        TreeNode*p=root;TreeNode*pre= nullptr;
        while (1){
            while(p!= nullptr){
                s.push(p);
                p=p->left;
            }
            if(s.empty())return res;
            p=s.top();
            if(p->right== nullptr||pre==p->right){
                s.pop();
                res.push_back(p->val);
                pre=p;//pre来确定右孩子是否访问过
                p= nullptr;//这里需要改p的指向，不然会一直重复将栈顶元素出入栈
            } else
            p=p->right;
        }
    }
};