代码随想录打卡13天 二叉的前中后序遍历，二叉树的层序遍历，翻转二叉树，

1.   144. 二叉树的前序遍历 - 力扣（LeetCode）

思路：递归和迭代法都可以，递归代码易懂

class Solution {
public:
    void Traversal(TreeNode*cur, vector<int> &vec){
        if(cur == NULL){
            return;
        }
        vec.push_back(cur->val);
        Traversal(cur->left, vec);
        Traversal(cur->right, vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        Traversal(root, result);
        return result;

    }
};

迭代法要借助 stack ，栈这种数据结构，而且要先把根节点的右子树放进栈里面，因为前序遍历是中 左 右，右在最后，所以右要先进，因为先进后出。

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

    }
};

94. 二叉树的中序遍历 - 力扣（LeetCode）

中序遍历的递归法跟前序遍历差不多，迭代法也要借助栈

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        TreeNode*cur = root;
        while(cur!= NULL || !st.empty()){
            if(cur!= NULL){
            st.push(cur);
            cur = cur->left;  
            } 
            else{
            cur = st.top();
            result.push_back(cur->val);
            st.pop();
            cur = cur->right;
            }
            
        }
        return result;

    }
};

后序遍历只掌握了 递归

2. 二叉树的层序遍历

层序遍历要用到队列这个数据结构

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int> > result;
        if(root == NULL){
            return result;
        }
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                vec.push_back(node->val);
                que.pop();
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
            result.push_back(vec);
        }
        return result;

    }
};

3. 226. 翻转二叉树 - 力扣（LeetCode）

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL){
            return root;
        }
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode*node = que.front();
                swap(node->left, node->right);
                que.pop();
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
        }
        return root;

    }
};

总结：二叉树的迭代遍历，要用到栈这个数据结构，二叉树的层序遍历和翻转二叉树有相似之处，

都要用到队列，而且都是一层一层进行，遍历每一层的时候，都要把该层节点的左右子树加进队列。