代码随想录算法训练营第十五天 | 题目 层序遍历 题目 226.翻转二叉树 （优先掌握递归） 题目 101. 对称二叉树 （优先掌握递归）

层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        //利用队列，先进先出
        queue<TreeNode*>que;
        if(root != NULL)que.push(root);
        vector<vector<int>>result;
        
        while(!que.empty()){
            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);
            }
            result.push_back(vec);//最终结果容器
        }
        return result;

    }
};

226.翻转二叉树

递归法：

class Solution {
public:
    //递归前序
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL)return root;
        swap(root->left,root->right);
        invertTree(root->left); //翻转左孩子
        invertTree(root->right);//翻转右孩子
        return root;
    }
};

迭代法：栈

class Solution {
public:
    //迭代前序
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL)return root;
        stack<TreeNode*>st;
        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;

    }
};

层次遍历（广度优先遍历） ：

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();
            while(size--){
                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. 对称二叉树 （优先掌握递归）

递归后序遍历：

class Solution {
public:
    //递归后序遍历
    bool compare(TreeNode* left,TreeNode* right) {
        //确定终止条件
        //先判断节点为空的情况
        if(left != NULL && right == NULL) return false;
        else if(left == NULL && right != NULL) return false;
        else if(left == NULL && right == NULL) return true;
        //判断节点不为空的情况
        else if(left->val != right->val) return false;   //用else if是因为，判断完后面是还有值相等的情况
        //值相等
        bool outside = compare(left->left, right->right);  //比较外侧的值是否相等
        bool inside = compare(left->right, right->left);// 比较内侧的值是否相等
        bool isSame = outside && inside;  //判断是否相等
        return isSame;

    }
    bool isSymmetric(TreeNode* root){
        if(root == NULL)return false;
        return compare(root->left,root->right);
    }
};

迭代法：

class Solution {
public:
    //使用迭代的方法
    bool isSymmetric(TreeNode* root) {
        if(root ==NULL)return false;
        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;
    }
};