代码随想录算法训练营第十五天|层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2

层序遍历

层序遍历是从左到右一层一层的遍历二叉树，需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

其中while循环每执行

一次层数加一，for循环则用来遍历每一层中的所有元素。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;    //二维数组用来存放结果
        queue<TreeNode*> que;       //定义队列处理节点
        if(root!=nullptr) que.push(root);      //头节点放入队列中
        while(!que.empty()){
            vector<int> vec;        //一维数组存放每层的节点val
            int size=que.size();    
            for(int i=0;i<size;i++){    
                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;
    }
};

递归实现： 

class Solution {
public:
    void order(TreeNode* cur,int depth,vector<vector<int>>& res){
        if(cur==nullptr) return;        //遇到空节点返回上一层
        if(res.size()==depth) res.push_back(vector<int>());
        res[depth].push_back(cur->val);     //
        order(cur->left,depth+1,res);
        order(cur->right,depth+1,res);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        int depth=0;            //层数
        order(root,depth,res);
        return res;
    }
};

代码随想录_层序遍历10道题

226.翻转二叉树 

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

反转二叉树就是左右子树互换 ，如图所示

那只需要在遍历的时候执行互换操作就可以了，但是知道注意的是在深度优先遍历时中序遍历不能像前序和后序遍历那样直接交换，因为中序遍历先处理左子树，之后处理根节点，再处理右子树，这样就导致交换之后本该处理的右子树变成了左子树，而左子树重复处理。

递归法：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr) return root;
        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) st.push(root);
        while(!st.empty()){
            TreeNode* node=st.top();
            if(node!=nullptr){
                st.pop();
                if(node->right) st.push(node->right);
                if(node->left) st.push(node->left);
                st.push(node);
                st.push(nullptr);
            }else{
                st.pop();
                node=st.top();
                st.pop();
                swap(node->left,node->right);
            }
        }
        return root;
    }
};

层序遍历：

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

101.对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

让外侧元素和外侧元素相等，内侧元素和内侧元素相等。

class Solution {
public:
    bool compare(TreeNode* left,TreeNode* right){
        if(left==nullptr&&right!=nullptr) return false;
        else if(left!=nullptr&&right==nullptr) return false;
        else if(left==nullptr&&right==nullptr) return true;
        else if(left->val!=right->val) return false;
        bool outside=compare(left->left,right->right);
        bool inside=compare(left->right,right->left);
        return outside&&inside;
    }
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr) return true;
        return compare(root->left,root->right);
    }
};

迭代法：

迭代法其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，所以使用栈和队列是一样的。使用队列

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr) return true;
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()){
            TreeNode* leftnode=que.front();que.pop();
            TreeNode* rightnode=que.front();que.pop();
            if(!leftnode&&!rightnode) continue;     //左右节点为空说明对称继续
            if((!leftnode||!rightnode||(leftnode->val!=rightnode->val))) return false;
            que.push(leftnode->left); que.push(rightnode->right);  //外侧节点入队
            que.push(leftnode->right); que.push(rightnode->left);  //内侧节点入队
        }
        return true;
    }
};

使用栈只需要把队列换成栈，其他代码不动。