leetcode刷题（第十五天）层序遍历 10 ； 226.翻转二叉树； 101.对称二叉树 2

最新推荐文章于 2024-07-25 11:44:32 发布

coisini-robot

最新推荐文章于 2024-07-25 11:44:32 发布

阅读量920

点赞数

分类专栏：代码随想录刷题文章标签：算法数据结构

本文链接：https://blog.csdn.net/coisiniroot/article/details/132532884

版权

代码随想录刷题专栏收录该内容

40 篇文章 1 订阅

订阅专栏

今日任务：层序遍历 10 ； 226.翻转二叉树； 101.对称二叉树 2

卡哥建议：

重点：

参考链接：代码随想录：代码随想录 (programmercarl.com)

层序遍历 10

题目讲解（全）：代码随想录

题目建议：看完本篇可以一口气刷十道题，试一试，层序遍历并不难，大家可以很快刷了十道题。

刷题链接：

102.二叉树的层序遍历

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，不要使用que.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);
            }
            result.push_back(vec);
        }
        return result;
    }
};

应用递归法实现

# 递归法
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

117.填充每个节点的下一个右侧节点指针II

104.二叉树的最大深度

111.二叉树的最小深度

视频讲解：

《代码随想录》算法视频公开课 (opens new window)：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历 (opens new window)

看到题目的第一思路：

看完代码随想录之后的想法：

自己实现过程中遇到哪些困难：

每日精华：

类似题目：

226.翻转二叉树

题目讲解（全）：代码随想录

题目建议：这道题目一些做过的同学理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。

刷题链接：力扣题目链接

递归法--前序遍历--后序遍历（顺序交换）

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) {
        if(root == nullptr)return root;
        invertTree(root->left);
        swap(root->left,root->right);
        invertTree(root->left);
        return root;
    }
};

迭代法--深度优先遍历--前序遍历--后序遍历（顺序交换）

class Solution {
public:
    //迭代法--深度优先遍历--前序遍历--后序遍历统一写法（顺序交换）
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) 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 == nullptr) return root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            TreeNode* node =st.top(); 
            if(node!=NULL){
                st.pop();
                if (node->right)st.push(node->right);
                st.push(node);
                st.push(NULL);
                if(node->left)st.push(node->left);
            }
            else{
                st.pop();
                node=st.top();
                swap(node->left,node->right);
                st.pop();
            }
        }
        return root;
    }
};

//迭代法--广度优先遍历

class Solution {
public:
    //迭代法--广度优先遍历
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return root;
        queue<TreeNode*> que;
        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;
    }
};

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

看到题目的第一思路：

看完代码随想录之后的想法：

自己实现过程中遇到哪些困难：

每日精华：

类似题目：

周末总结

写的还不错--复习也要看看；

101.对称二叉树 2

题目讲解（全）：代码随想录

题目建议：建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。

刷题链接：力扣题目链接

//递归法

class Solution {
public:
    //递归法
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;//01
        else if (left != NULL && right == NULL) return false;//10
        else if (left == NULL && right == NULL) return true;//00
        // else if (!left&& right == NULL) return true;//00
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;//12

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）//11
        return isSame;

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

//迭代法----队列

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) 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;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            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;
    }
};

//迭代法---栈

class Solution {
public:
    //迭代法---栈
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        stack<TreeNode*> st; // 这里改成了栈
        st.push(root->left);
        st.push(root->right);
        while (!st.empty()) {
            TreeNode* leftNode = st.top(); st.pop();
            TreeNode* rightNode = st.top(); st.pop();
            if (!leftNode && !rightNode) {
                continue;
            }
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;
    }
};

视频讲解：

《代码随想录》算法视频公开课 (opens new window)：同时操作两个二叉树 | LeetCode：101. 对称二叉树 (opens new window)

看到题目的第一思路：

看完代码随想录之后的想法：

自己实现过程中遇到哪些困难：

每日精华：

类似题目：100.相同的树

572.另一个树的子树

今日收获，记录一下自己的学习时长：

优质文章：学习参考：

coisini-robot

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode刷题（第十五天）层序遍历 10 ； 226.翻转二叉树； 101.对称二叉树 2

层序遍历 10；226.翻转二叉树；101.对称二叉树 2层序遍历 10看完本篇可以一口气刷十道题，试一试，层序遍历并不难，大家可以很快刷了十道题。应用递归法实现226.翻转二叉树这道题目一些做过的同学理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。递归法--前序遍历--后序遍历（顺序交换）递归法--中序遍历（也不叫中序遍历了就）迭代法--深度优先遍历--前序遍历--后序遍历（顺序交换）
复制链接

扫一扫