代码随想录算法训练营Day15|102.层序遍历、226.翻转二叉树、101.对称二叉树 C++

层序遍历

逐层遍历

         利用队列这个数据结构，每次存入一层的节点地址。当需要得知每层的值时，将队列中的元素全部出队，并将地址所指向节点的val值插入一个一维数组进行保存，然后将所有节点的左节点和右节点（若存在）全部依次入队。若队列为空，则说明逐层遍历完成。代码如下。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        // 创建一个空向量 ans，用于存储遍历的结果
        vector<vector<int>> ans;
        // 创建一个空队列 queue，用于辅助遍历
        queue<TreeNode*> queue;
        // 如果根节点为空，直接返回空向量 ans
        if (root == nullptr) {
            return ans;
        }
        // 将根节点推入队列
        queue.push(root);
        // 当队列不为空时，继续遍历
        while (!queue.empty()) {
            // 获取当前队列中节点的数量，即当前层的节点数
            int levelSize = queue.size();
            // 创建一个向量 currentLevel，用于存储当前层的节点值
            vector<int> currentLevel;
            // 遍历当前层的每个节点
            for (int i = 0; i < levelSize; i++) {
                // 从队列中取出一个节点
                TreeNode* cur = queue.front();
                // 将取出的节点的值添加到 currentLevel 向量中
                currentLevel.push_back(cur->val);
                // 将取出的节点从队列中移除
                queue.pop();
                // 如果取出的节点有左子节点，将其推入队列
                if (cur->left) {
                    queue.push(cur->left);
                }
                // 如果取出的节点有右子节点，将其推入队列
                if (cur->right) {
                    queue.push(cur->right);
                }
            }
            // 将 currentLevel 向量添加到 ans 向量中，作为下一层
            ans.push_back(currentLevel);
        }
        // 遍历完成后，返回存储遍历结果的 ans 向量
        return ans;
    }
};

代码的时间复杂度和空间复杂度均为O(n)

翻转二叉树

直接用递归，交换每个节点的左节点和右节点。

class Solution {
public:
    // 定义一个函数，用于交换二叉树中两个节点的左右子节点
    void swap(TreeNode *root) {
        TreeNode *temp = root->left; // 临时变量，用于交换左右子节点
        root->left = root->right; // 交换左右子节点
        root->right = temp;
    }

    // 定义一个函数，用于递归地翻转二叉树
    void change_node(TreeNode *cur) {
        if (!cur) { // 如果当前节点为空，返回
            return;
        }
        // 交换当前节点的左右子节点
        swap(cur);
        // 递归翻转当前节点的左子树
        change_node(cur->left);
        // 递归翻转当前节点的右子树
        change_node(cur->right);
    }

    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) { // 如果根节点为空，返回根节点
            return root;
        }
        // 递归调用 change_node 函数，从根节点开始翻转二叉树
        change_node(root);
        // 返回翻转后的根节点
        return root;
    }
};

算法的时间O(n)，n个节点，每个节点访问一次，空间复杂度为O(n)，考虑最差情况，树完全不平衡（链表），高度为n，空间复杂度为O(n)

对称二叉树

错误做法

        因为根据样例我发现二叉树的中序遍历结果如果是对称的，则二叉树是对称的，写了以下代码，发现[1,2,2,2,null,2]的样例通过不了，后中序遍历这个二叉树，符合代码逻辑，但不是堆成二叉树，所以前提假设是错误的。 195/199。

class Solution {
public:
    void inorder(TreeNode * cur,vector<int> &ivec){
        if(!cur){
            return;
        }
        inorder(cur->left,ivec);
        ivec.push_back(cur->val);
        inorder(cur->right,ivec);
    }
    bool isSymmetric(TreeNode* root) {
        vector<int> ivec;
        inorder(root,ivec);
        int length = ivec.size();
        for(int i = 0; i <ivec.size()/2;i++){
            if(ivec[i]!=ivec[length -1- i])
                return false;
        }
        return true;
    }
};

递归

        考虑使用递归方法，从节点根开始，一个向左，一个向右，判断相应位置是否相同，若相同，则对称，不同则返回false。

class Solution {
public:
    bool isMirror(TreeNode* t1, TreeNode* t2) {
        if (t1 == nullptr && t2 == nullptr) {
            return true; // 如果两个节点都为空，它们是对称的
        }
        if (t1 == nullptr || t2 == nullptr) {
            return false; // 如果一个节点为空，另一个不为空，它们不是对称的
        }
        if (t1->val != t2->val) {
            return false; // 如果两个节点的值不同，它们不是对称的
        }
        return isMirror(t1->left, t2->right) && isMirror(t1->right, t2->left); // 递归地比较左子树和右子树
    }    
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) {
            return true; // 如果树为空，则它是对称的
        }
        return isMirror(root->left, root->right);
    }
};

算法的时间和空间复杂度均为O(n)