二叉树LeetCode

107. 二叉树的层序遍历 II - 力扣（LeetCode）

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

思路：将二叉树层序遍历放入容器中再反转即可

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*>que;
        vector<vector<int>>res;
        if(!root)return res;
        que.push(root);
        while(!que.empty()){
            int size=que.size();
            vector<int>temp;
            for(int i=0;i<size;++i){
                if(que.front()->left){
                    que.push(que.front()->left);
                }
                if(que.front()->right){
                    que.push(que.front()->right);
                }
                temp.push_back(que.front()->val);
                que.pop();
            }
            res.push_back(temp);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

时间复杂度 O(n) 空间复杂度 O(1)

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

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点

思路：这道题其实就是将每一个节点的左右节点交换，其实质就是将所有节点遍历一遍并且进行交换操作

1.迭代：层序遍历

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

2.递归：先序遍历

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root)return root;
        TreeNode* l=root->left;
        TreeNode* r=root->right;
        root->left=r;
        root->right=l;
        if(root->left)invertTree(root->left);
        if(root->right)invertTree(root->right);
        return root;
    }
};

注意：迭代的时间复杂度是小于递归的，能使用迭代最好使用迭代