Day15 LeetCode144. 二叉树的前序遍历 145.二叉树的后序遍历 94.二叉树的中序遍历（递归和非递归方法实现）102. 二叉树的层序遍历 226. 翻转二叉树

 递归实现二叉树的前后中序遍历

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

思路：

        1.前序遍历就是先处理根结点，再处理左子树和右子树，顺序是根左右

        2.递归的临界条件是当前结点cur == NULL，返回void

代码：

 

class Solution {
public:
    /*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) {}
    };*/
    void traversal(TreeNode* cur, vector<int>& v){
        if(cur == NULL){
            return;
        }
        v.push_back(cur->val);//处理当前根结点
        traversal(cur->left, v);//处理左子树
        traversal(cur->right, v);//处理右子树
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> v;
        traversal(root, v);
        return v;
    }
};

题目：145. 二叉树的后序遍历 - 力扣（LeetCode）  

思路：

        1.前序遍历就是先处理左子树和右子树，再处理根结点，顺序是左右根

        2.递归的临界条件是当前结点cur == NULL，返回void

代码：

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& v){
        if(cur == NULL) return;
        traversal(cur->left, v);//左
        traversal(cur->right, v);//右
        v.push_back(cur->val);//根
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> v;
        traversal(root, v);
        return v;
    }
};

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

代码：

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& v){
        if(cur == NULL) return;
        traversal(cur->left, v);//左
        v.push_back(cur->val);//根
        traversal(cur->right, v);//右
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> v;
        traversal(root, v);
        return v;
    }
};

 非递归（迭代法）实现二叉树的前后中序遍历：

1.迭代法实现二叉树的前序遍历

思路：

        使用栈来实现递归的行为，前序遍历是根左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子，这样出栈的时候才是中左右的顺序。

代码：

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

2.迭代法实现二叉树的后序遍历

思路：

        先序遍历是中左右，调整代码循环顺序中右左，再反转res数组，得到左右中，就是后续遍历的顺序

代码：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
       stack<TreeNode*> st;
       vector<int> res;
       if(root == NULL) return res;
       st.push(root);
       while(!st.empty()){
           TreeNode* node = st.top();//中
           st.pop();
           res.push_back(node->val);
           if(node->left) st.push(node->left);//左
           if(node->right) st.push(node->right);//右
       }
       //输出是中右左
       reverse(res.begin(), res.end());//反转后是左右中
       return res;
    }
};

3.迭代法实现二叉树的中序遍历

思路：

        在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素

        定义一个cur指针指向头结点，用一个栈来保存遍历过的结点，如果cur不为空，一直往左遍历，将遍历过的结点都压入栈中，直到遍历到空结点，cur为空，则弹出栈顶元素就是我们要处理的元素，然后再往右遍历，将右子树都压入栈中直到cur为空再弹出。

代码：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;
        if(root == NULL) return res;
        TreeNode* cur = root;
        while(cur!= NULL || !st.empty()){
            if(cur != NULL){
                st.push(cur);
                cur = cur->left;//左
            }else{
                cur = st.top();// 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
                st.pop();
                res.push_back(cur->val);//中
                cur = cur->right;//右
            }
        }
        return res;
    }
};

题目：102. 二叉树的层序遍历 - 力扣（LeetCode）

思路：

        使用一个队列queue来保存我们遍历的结点，定义一个变量size记录遍历到的每一层的结点个数，比如当遍历到第一层时，size = 1，那们就可以知道从队列里需要弹出一个元素，每次弹出元素时依次把其左右孩子加入队列，此时size = 2，需要弹出两个元素就是第二层元素的个数，弹出第二层元素后，队列里有4个元素，size = 4，记录第三层元素的个数，依此类推。注意，需要用一个二维数组来保存每一层遍历的元素，而每一层元素的元素又是一个一维数组，同时这个一维数组是不断更新的，从遍历某一层开始刷新，直到这层遍历完，再把这个一维数组存进二维数组中，继续下一层的遍历。

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if(!root) return res;
        que.push(root);
        while(!que.empty()){
           // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            int size = que.size();
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(vec);
        }
        return res;
    }
};

题目：226. 翻转二叉树 - 力扣（LeetCode）

递归实现：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL) return NULL;
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

 非递归实现：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root == NULL) return NULL;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            if(node->right) st.push(node->right);
            if(node->left) st.push(node->left);
        }
        return root;
    }
};