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

目录

一、102. 二叉树的层序遍历

二、226. 翻转二叉树

三、101. 对称二叉树

---

一、102. 二叉树的层序遍历

题目链接：力扣

文章讲解：代码随想录

视频讲解： 讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历

题目：

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

代码：

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */

class Solution {
public:
    //迭代法
    void order(vector<vector<int>> &ans, int depth, TreeNode *node)//参数及返回值
    {
        if (!node) return;//停止条件
        if (depth == ans.size()) ans.push_back(vector<int>());//每层操作
        ans[depth].push_back(node->val);//中
        order(ans, depth+1, node->left);//左
        order(ans, depth+1, node->right);//右
        return; 
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        /*queue<TreeNode*> queue;
        if (root) queue.push(root);
        while (!queue.empty())
        {
            int size = queue.size();//一层的每个结点
            vector<int> floor;
            for (int i = 0; i < size; i++)//一层每个结点进行操作
            {
                TreeNode *node = queue.front();
                queue.pop();
                floor.push_back(node->val);
                if (node->left) queue.push(node->left);
                if (node->right) queue.push(node->right);
            }
            ans.push_back(floor);
        }*/
        order(ans, 0, root);
        return ans;
    }
};

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

⏲：5:25

总结：图论中的广度优先遍历

二、226. 翻转二叉树

题目链接：力扣

文章讲解：代码随想录

视频讲解：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树

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

代码：

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
    //递归法
    if (!root) return root;
    /*swap(root->left, root->right);
    invertTree(root->left);
    invertTree(root->right);*/
    //迭代法
    stack<TreeNode*> stack;
    stack.push(root);
    while (!stack.empty())
    {
        TreeNode* node = stack.top();
        stack.pop();
        swap(node->left, node->right);
        if (node->left) stack.push(node->left);
        if (node->right) stack.push(node->right);
    }
    return root;
    }
};

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

⏲：2:37

总结：先序遍历和后序遍历

三、101. 对称二叉树

题目链接：力扣

文章讲解：代码随想录

视频讲解：同时操作两个二叉树 | LeetCode：101. 对称二叉树

题目：给你一个二叉树的根节点 root， 检查它是否轴对称

代码：

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    bool compare(TreeNode* left, TreeNode*right){
        if (!left && right) return false;
        else if(!right && left) return false;
        else if(!right && !left) return true;
        if (right->val != left->val) return false;
        
        return compare(left->left, right->right) && compare(left->right, right->left);
        
    }
    bool isSymmetric(TreeNode* root) {
       if (!root) return true;
       return compare(root->left, root->right); 
    }
};

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

⏲：5:02

总结：对称是比较两棵子树是否相对。通过递归函数的返回值来判断两个子树的内侧节点和外侧节点分别是否相等，是在两棵树上进行比较！