【代码随想录37期】Day15 层序遍历、翻转二叉树、对称二叉树

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量204 收藏 4
点赞数 6
分类专栏： C++ leetcode 基础练习 文章标签： 算法 c++ 数据结构 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44722674/article/details/139117516
版权
leetcode 同时被 3 个专栏收录
85 篇文章 0 订阅
订阅专栏
基础练习
26 篇文章 0 订阅
订阅专栏
C++
25 篇文章 1 订阅
订阅专栏

层序遍历

代码随想录

102. 二叉树的层序遍历 - 力扣（LeetCode）

v1.0:迭代法  核心思路是每层统计队列大小，按这个大小pop，然后push子节点
/**
 * 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;
        if(root==nullptr)return result;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int size = q.size();
            vector<int> tmp;
            TreeNode * cur;
            while(size--)
            {
                cur = q.front();
                tmp.push_back(cur->val);
                q.pop();
                if(cur->left)q.push(cur->left);
                if(cur->right)q.push(cur->right);
            }
            result.push_back(tmp);
        }
        return result;
    }
};

v2.0：递归法  是使用数组表示的树，使用depth来做数组第一维度的下标
/**
 * 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 traversal(vector<vector<int>> &ret, TreeNode*cur, int depth)
    {
        if(cur==nullptr)return;
        if(ret.size()==depth)ret.push_back(vector<int>());
        ret[depth].push_back(cur->val);

        traversal(ret, cur->left, depth+1);
        traversal(ret, cur->right, depth+1);
    }
    
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if(root==nullptr)return result;
        int depth = 0;
        traversal(result, root, depth);
        return result;
    }
};

107. 二叉树的层序遍历 II - 力扣（LeetCode）

v1.0  递归法  很简单，正常层序遍历之后将result反转即可
/**
 * 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 traversal(vector<vector<int>> &result, TreeNode*cur, int depth)
    {
        if(cur==nullptr)return;
        if(depth==result.size())result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        traversal(result, cur->left, depth+1);
        traversal(result, cur->right, depth+1);
    }

    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        if(root==nullptr)return result;
        int depth=0;
        traversal(result, root, depth);
        reverse(result.begin(), result.end());
        return result;
    }
};

v2.0 : 迭代法 使用队列 通过队列的尺寸来限制下一次读的次数，注意要保持队列里面不能有空指针
/**
 * 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;
        if(root==nullptr)return result;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int n = q.size();
            vector<int> tmp;
            for(int i = 0; i <n;i++)
            {
                TreeNode *cur = q.front();
                tmp.push_back(cur->val);
                q.pop();
                if(cur->left)q.push(cur->left);
                if(cur->right)q.push(cur->right);
            }
            result.push_back(tmp);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

199. 二叉树的右视图 - 力扣（LeetCode）

v1.0: 迭代法，取每一行最后一个即可，注意不能舍弃左子树
/**
 * 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;
        if(root==nullptr)return result;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int size = q.size();
            for(int i = 0; i< size; i++)
            {
                TreeNode *cur = q.front();
                if(i==size-1)result.push_back(cur->val);
                q.pop();
                if(cur->left)q.push(cur->left);
                if(cur->right)q.push(cur->right);
            }
        }
        return result;
    }
};

v2.0:递归法
/**
 * 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 traversal(vector<vector<int>> &treeNodes, TreeNode* cur, int depth)
    {
        if(cur==nullptr)return;
        if(treeNodes.size()==depth)treeNodes.push_back(vector<int>());
        treeNodes[depth].push_back(cur->val);
        traversal(treeNodes, cur->left, depth+1);
        traversal(treeNodes, cur->right, depth+1);
    }

    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        vector<vector<int>> treeNodes;
        if(root==nullptr)return result;
        int depth = 0;
        traversal(treeNodes, root, depth);
        for(auto v:treeNodes)
        {
            result.push_back(v[v.size()-1]);
        }
        return result;
    }
};

637. 二叉树的层平均值 - 力扣（LeetCode）

v1.0 : 递归法 得到treeNodes后 再对treeNodes的每个元素取均值
/**
 * 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 traversal(vector<vector<int>> &treeNodes, TreeNode * cur, int depth)
    {
        if(cur==nullptr)return;
        if(treeNodes.size()==depth)treeNodes.push_back(vector<int>());
        treeNodes[depth].push_back(cur->val);
        traversal(treeNodes, cur->left, depth + 1);
        traversal(treeNodes, cur->right, depth + 1);
    }

    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        if(root==nullptr)return result;
        int depth = 0;
        vector<vector<int>> treeNodes;
        traversal(treeNodes, root, depth);
        for(auto v:treeNodes)
        {
            double sum = 0;
            double count = 0;
            for(int i:v)
            {
                sum += i;
                count++;
            }
            result.push_back(sum / count);
        }
        return result;
        
    }
};

v2.0: 迭代法

429. N 叉树的层序遍历 - 力扣（LeetCode）

v1.0:迭代法 一遍过~
/*
// 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>> treeNodes;
        if(root==nullptr)return treeNodes;
        queue<Node*> q;
        q.push(root);
        int depth = 0;
        while(!q.empty())
        {
            int size = q.size();
            treeNodes.push_back(vector<int>());
            for(int i = 0; i< size; i++)
            {
                Node* cur = q.front();
                q.pop();
                treeNodes[depth].push_back(cur->val);
                for(auto c:cur->children)
                {
                    q.push(c);
                }
            }
            depth++;            
        }
        return treeNodes;
    }
};

515. 在每个树行中找最大值 - 力扣（LeetCode）

v1.0:递归法 注意int的最小值：INT_MIN -2147483648
/**
 * 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 traversal(vector<vector<int>> &treeNodes, TreeNode *cur, int depth)
    {
        if(cur==nullptr)return;
        if(treeNodes.size()==depth)treeNodes.push_back(vector<int>());
        treeNodes[depth].push_back(cur->val);
        traversal(treeNodes, cur->left, depth+1);
        traversal(treeNodes, cur->right, depth+1);
    }
    vector<int> largestValues(TreeNode* root) {
        vector<vector<int>> treeNodes;
        if(root==nullptr)return vector<int>();
        int depth = 0;
        traversal(treeNodes, root, depth);
        vector<int> result(treeNodes.size(), INT_MIN);
        for(int i = 0; i <treeNodes.size();i++)
        {
            for(auto e:treeNodes[i])
            {
                if(e>result[i])result[i]=e;
            }
        }
        return result;
    }
};

116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

v1.0:迭代法
/*
// 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) {
        if(root==nullptr)return root;
        queue<Node*> q;
        q.push(root);
        while(!q.empty())
        {
            int size = q.size();
            for(int i = 0; i<size; i++)
            {
                Node* cur = q.front();
                q.pop();
                if(i!=size - 1)cur->next = q.front();
                if(cur->left)q.push(cur->left);
                if(cur->right)q.push(cur->right);
            }
        }
        return root;
        
    }
};

v2.0:递归法
/*
// 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:
    void traversal(Node* cur, vector<vector<Node*>>& treeNodes, int depth)
    {
        if(cur==nullptr)return;
        if(treeNodes.size()==depth)treeNodes.push_back(vector<Node*>());
        treeNodes[depth].push_back(cur);
        traversal(cur->left, treeNodes, depth+1);
        traversal(cur->right, treeNodes, depth+1);
    }
    Node* connect(Node* root) {
        vector<vector<Node*>> treeNodes;
        if(root==nullptr)return root;
        int depth = 0;
        traversal(root, treeNodes, depth); 
        for(int i = 0; i < treeNodes.size();i++)
        {
            for(int j = 0; j < treeNodes[i].size()-1;j++)
            {
                treeNodes[i][j]->next = treeNodes[i][j+1];
            }
        }
        return root;
    }
};

104. 二叉树的最大深度 - 力扣（LeetCode）

v1.0:迭代法
/**
 * 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) {
    int max_depth = 0;
    if(root==nullptr)return max_depth;
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty())
    {
        int size = q.size();
        if(size > 0)max_depth++;
        for(int i = 0; i < size; i++)
        {
            TreeNode* cur = q.front();
            q.pop();
            if(cur->left)q.push(cur->left);
            if(cur->right)q.push(cur->right);
        }
    }
    return max_depth;
    }
};

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

v1.0:递归法
/**
 * 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 min_depth = INT_MAX;
    void traversal(vector<vector<TreeNode*>>& treeNodes, TreeNode* cur, int depth)
    {
        if(cur==nullptr)return;
        if(treeNodes.size()==depth)treeNodes.push_back(vector<TreeNode*>());
        treeNodes[depth].push_back(cur);
        if(cur->left==nullptr && cur->right==nullptr &&depth<min_depth)min_depth = depth+1;
        traversal(treeNodes, cur->left, depth+1);
        traversal(treeNodes, cur->right, depth+1);
    }

    int minDepth(TreeNode* root) {
        if(root==nullptr)return 0;
        vector<vector<TreeNode*>> treeNodes;
        int depth = 0;
        traversal(treeNodes, root, depth);
        return min_depth;
    }
};

翻转二叉树

/**
 * 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==nullptr)return root;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty())
        {
            TreeNode* cur = s.top();
            s.pop();
            auto tmp = cur->left;
            cur->left = cur->right;
            cur->right = tmp;
            if(cur->left)s.push(cur->left);
            if(cur->right)s.push(cur->right);
        }
        return root;
    }
};

void traversal(TreeNode* cur)
{
    if (cur == nullptr)
        return;
    TreeNode* tmp = cur->left;
    cur->left = cur->right;
    cur->right = tmp;
    traversal(cur->left);
    traversal(cur->right);
}

TreeNode* mirrorTree(TreeNode* root) {
    traversal(root);
    return root;
}

对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr)return false;
        queue<TreeNode*> q;
        TreeNode* u = root;
        TreeNode* v = root;
        q.push(u);
        q.push(v);
        while(!q.empty())
        {
            u = q.front();
            q.pop();
            v = q.front();
            q.pop();
            if (!u && !v) continue;
            if((!u || !v) || (u->val!=v->val))return false;
            q.push(u->left);
            q.push(v->right);
            q.push(u->right);
            q.push(v->left);
        }
        return true;
    }
};

bool traversal(TreeNode* u, TreeNode* v)
{
    if (!u && !v)
        return true;
    if (!u || !v)
        return false;
    if (u->val == v->val)
        return traversal(u->left, v->right) && traversal(u->right, v->left);
    return false;
}

bool isSymmetric(TreeNode* root) {
    
    return traversal(root, root);
}
FangYwang
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣报错“AddressSanitizer: heap-buffer-overflow on address...”的解决办法
Law of Conservation of Eudaemonia
03-16 1万+
做力扣报了个错： AddressSanitizer: heap-buffer-overflow on address 0x6020000001cc at pc…… 大概意思 LeetCode使用了AddressSanitizer检查了是否存在内存非法访问,一般是数组越界，上下都有可能 Address Sanitizer（ASan）是一个快速的内存错误检测工具。从gcc 4.8开始，AddressSanitizer成为gcc的一部分。 解决方案 一般是修改循环条件，如:<改为<=
力扣报错“AddressSanitizer:DEADLYSIGNAL==ERROR: AddressSanitizer:stack-overflow on address“的解决方案
热门推荐
Law of Conservation of Eudaemonia
03-17 1万+
做力扣报了个错： AddressSanitizer: stack-overflow on address 0x6020000001cc at pc…… 大概意思 LeetCode使用了AddressSanitizer检查了是否存在无限递归,或是数组越界，我这里遇到的是无限递归 Address Sanitizer（ASan）是一个快速的内存错误检测工具。从gcc 4.8开始，AddressSanitizer成为gcc的一部分。 解决方案 无限递归就是看看怎么改一下跳出递归 数组越界一般是修改循环条
力扣812.最大三角形面积
Law of Conservation of Eudaemonia
01-24 1050
题目描述 给定包含多个点的集合，从其中取三个点组成三角形，返回能组成的最大三角形的面积。 示例 示例: 输入: points = [[0,0],[0,1],[1,0],[0,2],[2,0]] 输出: 2 解释: 这五个点如下图所示。组成的橙色三角形是最大的，面积为2。 注意 3 <= points.length <= 50. 不存在重复的点。 -50 <= points[i][j] <= 50. 结果误差值在 10^-6 以内都认为是正确答案。 解题思路 暴力解题：已
【代码随想录37期】 第一周总结
Law of Conservation of Eudaemonia
05-12 900
已知进入for循环时right<nums.size()，要满足sum >= target，left与right之间至少要有一个数，也就是nums[right]，此时left<right<nums.size();
【代码随想录37期】第二周总结
Law of Conservation of Eudaemonia
05-19 714
resize是为了把后面冗余的部分去掉至于新的大小为什么是slow，看slow的循环即可，slow最后多一个slow++，数值上正好是size的大小（大小为slow的下标是0 ~ slow-1）
【代码随想录37期】Day13 滑动窗口最大值、前K个高频元素
Law of Conservation of Eudaemonia
05-20 681
若设二叉树的深度为h，除第 h 层外，其它各层 (1~h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。如果使用大顶堆，队列的特点是只能从队头出，那样最大的元素就会被弹出，我们需要的就是最大的K个元素，所以应该使用小顶堆把最小的元素弹出。我们在力扣写代码时，是在solution类里面，我们直接在这里面写的函数是该类的成员函数，非静态成员函数有一个。，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，使用容器适配器：队列。
【代码随想录37期】Day14 二叉树的前序遍历、二叉树的中序遍历、二叉树的后序遍历
Law of Conservation of Eudaemonia
05-21 495
广度搜索：使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。，也就说前中后序遍历的逻辑其实都是可以借助栈使用递归的方式来实现的。
【代码随想录37期】Day01 二分查找 + 移除元素
Law of Conservation of Eudaemonia
05-08 485
二分查找详解 + 双指针移除元素 详解
力扣1523.在区间范围内统计奇数数目Count Odd Numbers in an Interval Range
Law of Conservation of Eudaemonia
01-04 465
题目描述 给你两个非负整数 low 和 high 。请你返回 low 和 high 之间（包括二者）奇数的数目。 示例 示例 1： 输入：low = 3, high = 7 输出：3 解释：3 到 7 之间奇数数字为 [3,5,7] 。 示例 2： 输入：low = 8, high = 10 输出：1 解释：8 到 10 之间奇数数字为 [9] 。 提示 0 <= low <= high <= 10^9 解题思路 本题直接遍历会超时 查看提示发现可以找区间内连续数字与奇数
【代码随想录37期】Day08 反转字符串、反转字符串Ⅱ、替换数字、反转字符串里面的单词、右旋转字符串
Law of Conservation of Eudaemonia
05-15 444
下面的声明和初始化创建了一个 “Hello” 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 “Hello” 的字符数多一个。字符串实际上是使用 null 字符 ‘\0’ 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。使用整体反转+局部反转就可以实现反转单词顺序的目的。而使用局部反转+整体反转就可以实现反转字母顺序的目的。问题：1. erase与for循环嵌套时间复杂度高。注意的一点是reverse是左闭右开。
【代码随想录37期】Day17 平衡二叉树、二叉树的所有路径、左叶子之和
Law of Conservation of Eudaemonia
05-24 434
平衡二叉树 int traversal(TreeNode* cur, int depth) { if (!cur) return depth; int left_depth = traversal(cur->left, depth + 1); int right_depth = traversal(cur->right, depth + 1); if (left_depth == -1 || right_depth == -1) r
C语言解力扣461.汉明距离
Law of Conservation of Eudaemonia
12-24 409
题目描述 两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。 给出两个整数 x 和 y，计算它们之间的汉明距离。 注意： 0 ≤ x, y < 231. 示例: 输入: x = 1, y = 4 输出: 2 解释: 1 (0 0 0 1) 4 (0 1 0 0) ↑ ↑ 上面的箭头指出了对应二进制位不同的位置。 解题思路 使用%2运算获得二进制最低位； 使用/2运算将次低位更新为最低位； 题目为1的位置不同的情况加一，则加上每一位的异或结果即可 代
【代码随想录37期】Day27 组合总和 40.组合总和II 131.分割回文串
Law of Conservation of Eudaemonia
06-04 385
【代码】【代码随想录37期】Day27 组合总和 40.组合总和II 131.分割回文串。
力扣507.完美数
Law of Conservation of Eudaemonia
12-30 372
题目描述 对于一个 正整数，如果它和除了它自身以外的所有 正因子 之和相等，我们称它为 「完美数」。 给定一个 整数 n， 如果是完美数，返回 true，否则返回 false 示例 示例 1： 输入：28 输出：True 解释：28 = 1 + 2 + 4 + 7 + 14 1, 2, 4, 7, 和 14 是 28 的所有正因子。 示例 2： 输入：num = 6 输出：true 示例 3： 输入：num = 496 输出：true 示例 4： 输入：num = 8128 输出：tru
【代码随想录37期】Day11 有效的括号、删除字符串中的所有相邻重复项、逆波兰表达式求值
Law of Conservation of Eudaemonia
05-19 372
3）遇到运算符“+”，将a和b出栈，执行a+b的操作，得到结果d=a+b，再将d入栈（0位置）两个元素弹出作相应运算，结果再入栈，最后当表达式扫描完后，栈里的就是结果。两个元素出栈，执行运算，得到的结果再入栈的原则来进行处理，那么ab+c。Notation，RPN，或逆波兰记法），也叫后缀表达式（将。经过以上运算，计算机就可以得到(a+b)*c的运算结果e了。,如果当前字符为变量或者为数字，则压栈，如果是运算符，则将。c的操作，得到结果e，再将e入栈（0位置）”，将d和c出栈，执行d。4）c入栈（1位置）
P1145 约瑟夫
zty20120913的博客
08-06 398
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 203
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 555
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
嵌入式初学-C语言-十五
MaBaB的博客
08-05 643
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值