代码随想录Day15——层序遍历 226.翻转二叉树 101. 对称二叉树

最新推荐文章于 2024-06-21 23:28:17 发布
最新推荐文章于 2024-06-21 23:28:17 发布
阅读量1k 收藏
点赞数
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cheng_dog/article/details/134299480
版权

层序遍历与226.翻转二叉树

使用队列，将每一层的元素入队，并记录每层元素个数，再该层每一个元素从队头出队时将其子节点从队尾入队，这样当上层元素全部出队后，其下层元素全部入队，重复上述操作，直到队列为空。下边11道题均可以使用该方法解决。

给你二叉树的根节点 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        vector<int> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return result;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(sub_res);
                sub_res.clear();
            }
        }
        return result;
    }
};

给你二叉树的根节点 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:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        vector<int> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return result;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(sub_res);
                sub_res.clear();
            }
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

给定一个二叉树的 根节点 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:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        vector<int> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return result;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(*(sub_res.end()-1));
                sub_res.clear();
            }
        }
        return result;
    }
};

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

/**
 * 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:
    double getAverage(vector<int> v)
    {
        double sum = 0;
        for(int i = 0;i<v.size();i++)
        {
            sum += v[i];
        }
        return sum/v.size();
    }
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        vector<int> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return result;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(getAverage(sub_res));
                sub_res.clear();
            }
        }
        return result;
    }
};

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        vector<int> sub_res;
        queue<Node*> q;
        int num;
        if(root == NULL)return result;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            for(int i = 0;i<q.front()->children.size();i++)
            {
                q.push(q.front()->children[i]);
            }
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(sub_res);
                sub_res.clear();
            }
        }
        return result;
    }
};

给定一棵二叉树的根节点 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:
    int getMax(vector<int> v)
    {
        if(v.empty()) return -1;
        int Max = v[0];
        for(int i = 1;i<v.size();i++)
        {
            Max = max(Max,v[i]);
        }
        return Max;

    }
    vector<int> largestValues(TreeNode* root) {
        vector<int> result;
        vector<int> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return result;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(getMax(sub_res));
                sub_res.clear();
            }
        }
        return result;
    }
};

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> sub;
        queue<Node*> q;
        int num;
        if(root == NULL)return root;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub.push(q.front());
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                Node* temp = sub.back();
                temp->next = NULL;
                while(sub.size()>1)
                {
                    temp = sub.front();
                    sub.pop();
                    temp->next = sub.front();
                }
                if(sub.size()==1) sub.pop();
            }
        }
        return root;
    }
};

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> sub;
        queue<Node*> q;
        int num;
        if(root == NULL)return root;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub.push(q.front());
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                Node* temp = sub.back();
                temp->next = NULL;
                while(sub.size()>1)
                {
                    temp = sub.front();
                    sub.pop();
                    temp->next = sub.front();
                }
                if(sub.size()==1) sub.pop();
            }
        }
        return root;
    }
};

给定一个二叉树 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:
    int maxDepth(TreeNode* root) {
        vector<vector<int>> result;
        vector<int> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return 0;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(sub_res);
                sub_res.clear();
            }
        }
        return result.size();
    }
};

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

/**
 * 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:
    int minDepth(TreeNode* root) {
        vector<vector<int>> result;
        vector<int> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return 0;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front()->val);
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            if(q.front()->left == NULL && q.front()->right == NULL) return result.size()+1;
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                result.push_back(sub_res);
                sub_res.clear();
            }
        }
        return result.size();
    }
};

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

示例 1：

/**
 * 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) {
        //vector<vector<int>> result;
        vector<TreeNode*> sub_res;
        queue<TreeNode*> q;
        int num;
        if(root == NULL)return root;
        q.push(root);
        num = q.size();
        while(!q.empty())
        {
            sub_res.push_back(q.front());
            if(q.front()->left != NULL)q.push(q.front()->left);
            if(q.front()->right != NULL)q.push(q.front()->right);
            q.pop();
            num--;
            if(num == 0)
            {
                num = q.size();
                TreeNode* temp;
                for(int i = 0;i<sub_res.size();i++)
                {
                    if(sub_res[i]->left) temp = sub_res[i]->left;
                    else temp = NULL;
                    if(sub_res[i]->right) sub_res[i]->left = sub_res[i]->right;
                    else sub_res[i]->left = NULL;
                    sub_res[i]->right = temp;
                }
                sub_res.clear();
            }
        }
        return root;
    }
};

 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 subSymmetric(TreeNode* T1,TreeNode* T2)
    {
        bool b1 = true;
        bool b2 = true;
        if(T1->val == T2->val)
        {
            if(T1->left == NULL && T1->right == NULL && T2->left == NULL && T2->right == NULL) return true;
            else
            {
                if(T1->left != NULL && T2->right != NULL)b1 = subSymmetric(T1->left,T2->right);
                else if((T1->left == NULL && T2->right != NULL)||(T1->left != NULL && T2->right == NULL)) return false;
                if(T2->left != NULL && T1->right != NULL)b2 = subSymmetric(T2->left,T1->right);
                else if((T2->left == NULL && T1->right != NULL)||(T2->left != NULL && T1->right == NULL)) return false;
                if(b1 && b2) return true;
            }
        }
        return false;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        if(!(root->left||root->right)) return true;
        if((root->left == NULL && root->right != NULL)||(root->left != NULL && root->right == NULL)) return false;
        if(root->left->val != root->right->val) return false;
        return subSymmetric(root->left,root->right);
    }
};

虽然解出来了，但是思路并不系统，根据不同情况的问题才更改完善的。

cheng_dog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
java-leetcode题解之第107题二叉树的层序遍历II.zip
06-18
java java_leetcode题解之第107题二叉树的层序遍历II
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历.txt
05-20
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
python python_leetcode面试题解之第107题二叉树的层序遍历II
多目标跟踪 (MOT) 算法简介
weixin_41446370的博客
06-18 405
多目标跟踪 (MOT) 是一项计算机视觉任务，旨在识别和跟踪视频序列中的多个目标。与单目标跟踪不同，MOT 需处理多个目标的相互遮挡、消失和重新出现等复杂情况。
算法篇-二叉树
分享Java知识，记录思考和感悟
06-21 179
分享二叉树相关概念和算法题
算法基础精选题单 动态规划（dp）（区间dp）（个人题解）
Wzh20060111的博客
06-21 465
目录前言：正文： 题单：【237题】算法基础精选题单_ACM竞赛_ACM/CSP/ICPC/CCPC/比赛经验/题解/资讯_牛客竞赛OJ_牛客网 (nowcoder.com)NC50493 石子合并：NC50500 凸多边形的划分：NC235246 田忌赛马：NC13230 合并回文子串:NC16645 [NOIP2007]矩阵取数游戏：NC207781 迁徙过程中的河流：后记： 这些dp对我来说就没那么简单了，但写过这些题目之后我确实对区间dp有了一个简单的认识，区间dp一般都是二维的，由第一维表示左
189.二叉树：将有序数组转换为二叉搜索树（力扣）
weixin_63779802的博客
06-21 101
代码使用了递归的方法。主要思路是首先找到数组的中间元素，然后以这个中间元素作为根节点，递归地在数组中构建左右子树。左子树包含数组中所有小于中间元素的元素，右子树包含所有大于中间元素的元素。这个算法的时间复杂度是 O(n)，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
力扣54. 螺旋矩阵
akdjfhx的博客
06-16 251
力扣54. 螺旋矩阵
455. 分发饼干
SHUOSHUREN233的博客
06-20 106
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j]。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。本题我的思路是小饼干优先满足胃口小的小孩，但没有弄清楚遍历顺序，也没有正确的移动下标，导致代码一直出错，使用一个int型变量来控制小孩数组的遍历，并且统计满足小孩的数量即可。假设你是一位很棒的家长，想要给你的孩子们一些小饼干。，并输出这个最大数值。
力扣1793.好子数组的最大分数
Pisasama的博客
06-21 147
【代码】力扣1793.好子数组的最大分数。
openjudge_2.5基本算法之搜索_8436:Saving Tang Monk
adam_life的博客
06-21 469
openjudge_2.5基本算法之搜索_8436:Saving Tang Monk
*算法训练（leetcode）第十四天 | 513. 找树左下角的值、112. 路径总和、106. 从中序与后序遍历序列构造二叉树、D
weixin_43872997的博客
06-21 774
LeetCode刷题日记
实现一个快速排序算法，并分析算法的时间复杂度。
m0_45127365的博客
06-21 514
在最好情况下，每次划分时都能将数组均匀地划分为两个部分，此时时间复杂度为O(nlogn)。在最坏情况下（每次划分都只将数组中的一个元素放到正确位置），时间复杂度为O(n^2)。平均时间复杂度为O(nlogn)。
【LeetCode刷题】6. Z 字形变换
m0_71259890的博客
06-21 220
中间行， （k, d - k） => (k + d, d - k + d) = > (k + 2d, d - k + 2d) => ……最后1行，（numRows）=> (numRows + d) => (numsRows + 2d) =>第1行， （0） => 0 + d => 0 + 2d =>。最后附上我的打卡记录，希望各位大佬可以监督我。根据上面推出的式子，即可写出代码模拟。从下标来看，每个下标是有规律的。我们再以下标来看看排列。
手撕排序2--选择排序(直接选择+堆排序
最新发布
2302_81153999的博客
06-21 252
把最大的换到最后，不把其看做是堆里的。前n-1个数向下调整，选出次大的数，再跟倒数第二个位置交换........每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。堆排序是利用堆 这种数据结构而设计的一种排序算法，它是选择排序的一种。将该节点与左右子树的节点进行比较，重新构建成一个大堆或者小堆。每个结点的值都小于或等于其左右孩子结点的值，称为。每个结点的值都大于或等于其左右孩子结点的值。物理结构是：一个数组。1. 对待排序的数组，先构建成 堆。
代码随想录算法训练营第四十一天| 416. 分割等和子集
qq_44388663的博客
06-18 158
题目链接：https://leetcode.cn/problems/partition-equal-subset-sum/description/文章链接：https://programmercarl.com/0416.%E5%88%86%E5%89%B2%E7%AD%89%E5%92%8C%E5%AD%90%E9%9B%86.html。
【CT】LeetCode手撕—415. 字符串相加
weixin_44382896的博客
06-21 182
【代码】【CT】LeetCode手撕—415. 字符串相加。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值