代码随想录day14

## 二叉树

### 144 前序
```C++
//递归
/**
 * 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>& res){
        if(root==nullptr){
            return;
        }
        res.push_back(root->val);
        preOrder(root->left,res);
        
        preOrder(root->right,res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        preOrder(root,res);
        return res;
    }
};

//迭代
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {

        vector<int> res;
        stack<TreeNode*> pre_stack;
        if(root==nullptr){
            return res;
        }
        pre_stack.push(root);

        while(!pre_stack.empty()){
            TreeNode* temp=pre_stack.top();
            pre_stack.pop();
            if(temp!=nullptr){
                res.push_back(temp->val);

            }else{
                continue;
            }
            pre_stack.push(temp->right);
            pre_stack.push(temp->left);

        }
        return res;
    }
};
```

### 145 后序

```C++

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

    }
};

//迭代
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> pre_stack;
        if(root==nullptr){
            return res;
        }
        pre_stack.push(root);

        while(!pre_stack.empty()){
            TreeNode* temp=pre_stack.top();
            pre_stack.pop();
            if(temp!=nullptr){
                res.push_back(temp->val);

            }else{
                continue;
            }
            
            pre_stack.push(temp->left);
            pre_stack.push(temp->right);

        }
        reverse(res.begin(),res.end());
        return res;
    }
};
```

### 94 中序
```c++
//递归
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) {
        stack<TreeNode*> in_stack;
        vector<int> res;
        //in_stack.push(root);
        TreeNode* temp=root;
        while(temp!=nullptr||!in_stack.empty()){
            if(temp!=nullptr){
                in_stack.push(temp);
                temp=temp->left;
                
            }else{
                temp=in_stack.top();
                res.push_back(temp->val);
                in_stack.pop();
                temp=temp->right;
            }
        }
        return res;

    }
};
```