代码随想录算法训练营第十五天|层序遍历

最新推荐文章于 2024-10-19 11:17:13 发布
最新推荐文章于 2024-10-19 11:17:13 发布
阅读量955 收藏 30
点赞数 26
文章标签： 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42797677/article/details/139142599
版权

代码随想录算法训练营第十五天|层序遍历

102. 二叉树的层序遍历

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

示例 1：

https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

思路

本题可以通过队列的方式来实现层序遍历，具体步骤如下

定义队列，并将root加入队列

在队列不为空的情况下循环遍历队列中的元素

循环次数通过size来维护，size值反应了每层元素的个数

具体的示意图如下所示：

https://code-thinking.cdn.bcebos.com/gifs/102二叉树的层序遍历.gif

具体代码如下：

/**
 * 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) {
        queue<TreeNode*> que;
        // 根不为空 将root加入队列
        if(root!=NULL){
            que.push(root);
        }
        // 定义存储结果变量
        vector<vector<int>> result;
        // 当队列为空时循环结束
        while(!que.empty()){
            // 定义每层的结果存储变量
            vector<int> vec;
            // 定义要循环的次数
            int 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;
    }
};

107. 二叉树的层序遍历Ⅱ

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：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) {
        queue<TreeNode*> que;
        if(root!=NULL){
            que.push(root);
        }
        vector<vector<int>> result;
        while(!que.empty()){
            vector<int> vec;
            int size = que.size();
            for(int i = 0; i<size; i++){
                TreeNode* node;
                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);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例 1:

https://assets.leetcode.com/uploads/2021/02/14/tree.jpg

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

思路

该题可以直接将每层循环的vec的back添加到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:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        vector<int> result;
        while(!que.empty()){
            vector<int> vec;
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode* node;
                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.back());
        }
        return result;
    }
};

还可以判断只将每层的最后一个元素添加到result中

具体的判断方式是i == size-1;

637. 二叉树的层平均值

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

示例 1：

https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

思路

本题就是层序遍历的时候把一层求个总和在取一个均值

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

429. N叉树的层序遍历

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

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

示例 1：

https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

思路

这道题依旧是模板题，只不过一个节点有多个孩子了

/*
// 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) {
        queue<Node*> que;
        if(root!=NULL) que.push(root);
        vector<vector<int>> result;
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            for(int i = 0; i < size; i++){
                Node* node;
                node = que.front();
                que.pop();
                vec.push_back(node->val);
                for(int j = 0; j<node->children.size();j++){
                    if(node->children[j]) que.push(node->children[j]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例1：

https://assets.leetcode.com/uploads/2020/08/21/largest_e1.jpg

输入:root = [1,3,2,5,3,null,9]
输出:[1,3,9]

示例2：

输入:root = [1,2,3]
输出:[1,3]

思路

层序遍历，取每一层的最大值

/**
 * 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> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        vector<int> result;
        while(!que.empty()){
            int size = que.size();
            int max = INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode* node = que.front();
                que.pop();
                max = max>node->val ? max : node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(max);
        }
        return result;
        
    }
};

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

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

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

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

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

示例 1：

https://assets.leetcode.com/uploads/2019/02/14/116_sample.png

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

示例 2:

输入：root = []
输出：[]

思路

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了

具体代码如下

/*
// 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*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            Node* nodePre;
            Node* node;
            for(int i = 0; i < size ; i++){
                if(i==0){
                    nodePre = que.front(); // 取出每一层的头节点
                    que.pop();
                    node = nodePre; // 因为后续要用node来添加下一层的节点 所有node也要赋值
                }else{
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 前一个节点next指向本节点
                    nodePre = node; // 前一个节点移动到当前位置，便于下一次指向
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            nodePre->next = NULL;
        }
        return root;
    }
};

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

给定一个二叉树：

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

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

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

示例 1：

https://assets.leetcode.com/uploads/2019/02/15/117_sample.png

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

示例 2：

输入：root = []
输出：[]

思路

和上个题目一模一样

/*
// 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*> que;
        if(root != NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            Node* nodePre;
            Node* node;
            for(int i = 0; i < size ; i++){
                if(i==0){
                    nodePre = que.front(); // 取出每一层的头节点
                    que.pop();
                    node = nodePre; // 因为后续要用node来添加下一层的节点 所有node也要赋值
                }else{
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 前一个节点next指向本节点
                    nodePre = node; // 前一个节点移动到当前位置，便于下一次指向
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            nodePre->next = NULL;
        }
        return root;
    }
};

104. 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg

输入：root = [3,9,20,null,null,15,7]
输出：3

示例 2：

输入：root = [1,null,2]
输出：2

思路

记录一下遍历的层数就是二叉树的深度

/**
 * 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) {
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        int depth = 0;
        while(!que.empty()){
            depth++;
            int size = que.size();
            for(int i = 0; i < size ; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

111. 二叉树的最小深度

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

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

**说明：**叶子节点是指没有子节点的节点。

示例 1：

https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：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:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root!=NULL) que.push(root);
        int depth = 0;
        while(!que.empty()){
            depth++;
            int size = que.size();
            for(int i = 0; i < size ; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                if(node->left == NULL && node->right == NULL){
                    return depth;
                }
            }
        }
        return depth;
    }
};

📎 参考文章

代码随想录0102.二叉树的层序遍历

￰￰￰￰￰￰￰￰liuiu
关注
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录训练营第五天
07-23
### 代码随想录训练营第五天：深入理解哈希表及其实现 #### 哈希表概述 哈希表是一种数据结构，它能够通过关键码的值来进行快速访问。这种数据结构允许我们实现非常高效的查找、插入和删除操作。在哈希表中，每个...
Javascript算法——双指针法移除元素、数组去重、比较含退格字符、有序数组平方
警警的博客
10-17 459
暴力求解法（两层for循环）,length单词拼写错误❌二次嵌套for的length设置。return位置❌ ,核心基础。双指针法（一层for循环）
【文档智能】文本文字识别、公式识别、表格文字识别核心算法及思路及实践-DBNet、CRNN、TrOCR
余俊晖，NLP炼丹师，目前专注自然语言处理领域研究。曾获得国内外自然语言处理算法竞赛TOP奖项近二十项。
10-13 1417
OCR技术作为文档智能解析链路中的核心组件之一，贯穿整个技术链路，包括：文字识别、表格文字识别、公式识别，参看下面这张架构图：前期介绍了很多关于文档智能解析相关核心技术及思路，本着连载的目的，本次迎来介绍整个链路中的最后一块拼图-OCR。本文简要介绍OCR常见落地的算法模型-DBNet、CRNN，并基于这两个模型，简单介绍文字识别在表格识别中参与的角色；并且额外介绍TrOCR这个端到端的模型，基于这个模型引入公式识别解析的思路及微调方法。
【算法】双指针
2303_80828380的博客
10-13 812
力扣oj题之双指针算法
C++中的vector介绍（常用函数）
zxybf_的博客
10-15 883
vector的文档介绍vector是序列容器，表示可以改变大小的数组。(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造int main()//无参的构造//n个val的构造//拷贝构造//迭代器区间构造return 0;
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 328
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1235
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
力扣10.13
qq_40052678的博客
10-13 478
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 347
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
LeetCode题练习与总结：二维区域和检索 - 矩阵不可变--304
一直学习永不止步
10-13 919
本文详细介绍了如何使用前缀和矩阵解决二维矩阵子矩形范围内元素总和的计算问题，包括解题思路、具体代码实现以及时间复杂度和空间复杂度分析，为高效处理此类问题提供了有效方法。
端盘子问题（二分查找+广度优先）
u012011912的博客
10-16 301
终于中午放学铃声打响了，小明想要尽快地前往食堂打自己最喜欢吃的菜。小明觉得，他会准备好若干个盘子再出发，带了几个盘子就打几份菜。但是一路上人群拥挤程度不同，如果太过拥挤，小明会拿不稳太多盘子。经过观察，小明发现食堂的地形可以用一个(1,1)(n,n)小明行走，并且每次可以花费 1 秒，从当前位置(i, j)移动到相邻的(i+1, j)(i, j+1)(i-1, j)或(i, j-1)。(1,1)(n,n)如果无论如何也不能在规定时间内到达终点，输出0。第一行包含两个整数n和Tnn × nT接下来n。
详细说明如何使用C++编写A*算法
最新发布
zsy54577的博客
10-19 1077
它结合了广度优先搜索的全面性和深度优先搜索的效率，通过估计当前路径代价和到达目标的预估代价，来找到从起点到目标的最短路径。类型的指针，它指向当前节点的父节点。在路径搜索树中，每个节点（除了根节点）都有一个父节点，指向它在树中的直接上级。这个指针用于重建从起点到终点的路径，一旦找到终点，可以通过追踪这些父节点指针回溯到起点。通过构建一个优先队列，A*算法每次从未探索的节点中选择f值最小的节点进行扩展，直至找到目标节点或遍历完整个搜索空间。
PMRF：一种新的图像恢复算法 高质量修复图像 降低图像失真还原跟自然逼真度
GDL_MPY的博客
10-14 1054
（Posterior-Mean Rectified Flow，后验均值修正流）是一种新提出的图像恢复算法，旨在解决图像恢复任务中的。在去噪、超分辨率、修复等不同图像恢复任务中，PMRF能够在多个图像质量评估指标（如PSNR、SSIM、FID等）上表现出色，且没有明显的弱点，展示了其在多任务环境下的稳健性。图像恢复任务（如去噪、超分辨率、盲恢复等）中，常常需要在（如均方误差MSE）和（如图像的真实感和自然度，使用FID、SSIM等衡量）之间做权衡。
深度解析RLS（Recursive Least Squares）算法
weixin_52734695的博客
10-15 1205
RLS（Recursive Least Squares）算法作为一种自适应滤波的强大工具，凭借其快速收敛和高精度的特性，广泛应用于信道均衡、噪声消除、系统辨识等场景中。虽然它的计算复杂度较高，但其优越的性能在许多高要求场景中展现了不可替代的价值。总的来说，RLS算法的核心在于最小化所有历史误差的平方和，并通过递归更新滤波器的系数。尽管其计算复杂，但通过合理优化，如引入遗忘因子或采用高效矩阵运算技术，可以显著提升其计算效率。
【博士每天一篇文献-算法】多任务学习之MGDA算法：Multi-Task Learning as Multi-Objective Optimization
BetterBench的博客
10-15 1263
本文提出了一种基于梯度的多目标优化算法，用于多任务学习，该算法通过优化一个上界来高效地找到帕累托最优解，且只需单次反向传播。
代码随想录算法训练营
08-23
训练营还提供了每日的讨论知识点，例如在第15天的讨论中，介绍了层序遍历的方法和使用队列来模拟一层一层遍历的效果。在第16天的讨论中，重点讨论了如何进行调试（debug）的方法，认为掌握调试技巧可以帮助学员更好...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值