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

最新推荐文章于 2024-08-10 07:14:43 发布
最新推荐文章于 2024-08-10 07:14:43 发布
阅读量36 收藏
点赞数
分类专栏： 代码随想录算法训练营 文章标签： 算法 c++ Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuiisy/article/details/129108261
版权

层序遍历

思路：

用size去记录每一层的节点数量，而不是用que.size()，因为que.size()在遍历过程中一直在变化。

需要记住层序遍历的模板！

相关题目

102. 二叉树的层序遍历

代码：

  • 迭代法

/**
 * 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;
        queue<TreeNode*>que;
        if(root!=nullptr)
            que.push(root);
        while(!que.empty())
        {
            vector<int>vec;
            int size = que.size();
            while(size--)
            {
                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;

    }
};

  • 递归法

/**
 * 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;
        int depth = 0;
        Order(root,result,depth);
        return result;
    }

    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);
    }

};

107. 二叉树的层序遍历 II

代码：

  • 迭代法

/**
 * 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;
        queue<TreeNode*>que;
        if(root!=nullptr)
            que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            vector<int>vec;
            while(size--)
            {
                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);
        }
        reverse(result.begin(),result.end());
        return 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<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>>result;
        int depth = 0;
        Order(root,result,depth);
        reverse(result.begin(),result.end());
        return result;
    }

    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);
    }

};

199. 二叉树的右视图

代码：

  • 第一次错在没有理解题意，以为只要返回右子树的值即可。

  • 第二次错在没有想到要在什么时候将值加入到数组中

/**
 * 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;
        queue<TreeNode*>que;
        if(root!=nullptr)
            que.push(root);
        while(!que.empty())
        {
            int size  = que.size();

            for(int i = 0;i<size;i++)
            {
                TreeNode *node = que.front();
                que.pop();
                if(i==(size-1))
                {
                    result.push_back(node->val);
                }
                if(node->left)
                    que.push(node->left);
                if(node->right)
                    que.push(node->right);
            }
        }
            
        return result;
    }
};

637. 二叉树的层平均值

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

    }
};

429. N 叉树的层序遍历

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

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

代码：

  • 第一次错是因为没看到还有负数值

/**
 * 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) {
        vector<int>result;
        queue<TreeNode*>que;
        if(root!=nullptr)
            que.push(root);
        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);
                if(node->left)  que.push(node->left);
                if(node->right)  que.push(node->right);
            }
            result.push_back(Max);
        }
        return result;
    }
};

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

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

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

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

104. 二叉树的最大深度

代码：
/**
 * 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!=nullptr)   que.push(root);
        int depth = 0;

        while(!que.empty())
        {
            int size = que.size();
            while(size--)
            {
                TreeNode *node = que.front();
                que.pop();
                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
            depth++;
        }
        return depth;
    }
};

111. 二叉树的最小深度

代码：

  • 迭代法

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

    }
};

总结

第一次学习层序遍历二叉树。一鼓作气做了十道题，收获满满，练习量也达到了。

LeetCode 226 翻转二叉树

题目链接：https://leetcode.cn/problems/invert-binary-tree/

思路：

采用遍历的方式对二叉树进行”翻转“，即将左右子树进行交换。注：递归遍历中的中序遍历不能直接使用。

代码：

  • 前序遍历（递归遍历）

/**
 * 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) {
        inver(root);
        return root;

    }

    void inver(TreeNode *cur)
    {
        if(cur==nullptr)    return;
        /*
        TreeNode *tmp = cur->left;
        cur->left = cur->right;
        cur->right = tmp;
        */
        swap(cur->left,cur->right);
        inver(cur->left);
        inver(cur->right);
    }

};

  • 前序遍历（迭代遍历）

/**
 * 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) {
        stack<TreeNode*>st;
        if(root==nullptr)   return root;
        st.push(root);
        while(!st.empty())
        {
            TreeNode *node = st.top();  //中
            st.pop();
            swap(node->left,node->right);

            if(node->left)  st.push(node->left);    //左
            if(node->right) st.push(node->right);   //右
        }
        return 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) {
        queue<TreeNode*>que;
        if(root!=nullptr)   que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            while(size--)
            {
                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;
    }
};

总结

自己写的话写出来了递归遍历的前序遍历。以后做二叉树的题目需要好好思考使用哪种遍历方式来做。

LeetCode 101 对称二叉树

题目链接：https://leetcode.cn/problems/symmetric-tree/

思路：

判断是否是对称二叉树即判断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 isSymmetric(TreeNode* root) {
        return compare(root->left,root->right);

    }

    bool compare(TreeNode *left,TreeNode *right)
    {
        if(!left&&right)    return false;
        else if(left&&!right)   return false;
        else if(!left&&!right)  return true;
        else if(left->val!=right->val)  return false;
        bool outside = compare(left->left,right->right); //左子树的左节点和右子树的右节点比较，即树的外侧比较
        bool inside = compare(left->right,right->left);  //左子树的右节点和右子树的左节点比较，即树的内侧比较
        bool isSame = inside&&outside;  //将信息返回给父节点，即后序遍历中的中

        return isSame;
    }

};

  • 队列-迭代法

/**
 * 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 isSymmetric(TreeNode* root) {
        queue<TreeNode*>que;
        if(root==nullptr)   return true;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty())
        {
            TreeNode *left = que.front();
            que.pop();
            TreeNode *right = que.front();
            que.pop();

            if(!left&&!right)   continue;

            if((!left||!right||left->val!=right->val))
                return false;
            
            que.push(left->left);   // 左子树的左节点   外
            que.push(right->right); // 右子树的右节点   外
            que.push(left->right);  // 左子树的右节点   内
            que.push(right->left);  // 右子树的左节点   内
        }
        return true;
    }
};

  • 栈-迭代法

/**
 * 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 isSymmetric(TreeNode* root) {
        stack<TreeNode*>st;
        if(root==nullptr)   return true;
        st.push(root->left);
        st.push(root->right);
        while(!st.empty())
        {
            TreeNode *left = st.top();
            st.pop();
            TreeNode *right = st.top();
            st.pop();

            if(!left&&!right)   continue;

            if((!left||!right||left->val!=right->val))
                return false;
            
            st.push(left->left);   // 左子树的左节点   外
            st.push(right->right); // 右子树的右节点   外
            st.push(left->right);  // 左子树的右节点   内
            st.push(right->left);  // 右子树的左节点   内
        }
        return true;
    }
};

总结

在做题的时候还需要先思考使用哪种遍历方式或者题目和哪种遍历方式接近，多加练习。

今日总结：

还需要多加练习，第一次接触二叉树的题目，基本都要先看视频再去做。希望二刷可以有所改变。

kuiisy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-leetcode题解之第107题二叉树的层序遍历II.zip
06-18
本压缩包文件“java-leetcode题解之第107题二叉树的层序遍历II.zip”显然是针对LeetCode上的第107题的一个解决方案，该题目涉及到二叉树的层序遍历，但有一个特殊的变体。下面我们将深入探讨这个知识点。 首先，...
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
用户可以通过阅读代码了解二叉树的构建方法和遍历算法的具体实现细节，也可以直接运行代码进行测试，加深对二叉树的理解。同时，这是一个很好的实践项目，可以帮助初学者巩固数据结构基础，提高编程技能。 总结来说...
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
本题解针对LeetCode上的第107题，即“二叉树的层序遍历II”，我们将深入探讨该问题的背景、解决方案以及它在面试中的重要意义。 二叉树是计算机科学中一种基本的数据结构，由节点组成，每个节点最多有两个子节点，...
二叉树的层序遍历 II.md
11-17
二叉树的层序遍历 II.md
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
P1145 约瑟夫
zty20120913的博客
08-06 431
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 944
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
m0_73924943的博客
08-08 275
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 587
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
备战秋招60天算法挑战，Day13
溜达虎的博客
08-06 767
在我们刷题的时候，适当的借助现有的数据结构往往会起到事半功倍的效果，今天我们讨论一下栈的使用。栈的特点是先进后出，利用栈的这个特点可以巧妙的解决很多问题，借助下面这道题我们进一步来体会一下栈的妙用。给定一个只包括 ，，，，， 的字符串 ，判断字符串是否有效。有效字符串需满足：举个例子： 视频题解 有效的括号 思路来源 思路来源 思路解析 首先要理解题意，什么才是题目中描述的有效括号，比如, 如下图，把同类型的括号单独按顺序拆出来，每种类型的括号都是能闭合的，但是并不是合法的。因为最先和闭合的是，违背了
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 897
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
基于LQR算法的机器人轨迹跟踪控制详解
最新发布
慕羽★的博客
08-10 1430
本文详细介绍了基于线性二次型调节器（LQR）算法的机器人轨迹跟踪控制方法。首先，文章通过建立基于运动学模型的离散状态方程，来描述机器人的当前状态与目标状态之间的关系，并利用此模型进行状态误差的计算。接着，通过设定状态量和控制量的权重矩阵（Q和R），使用LQR算法求解控制输入u，旨在最小化状态偏差和控制成本，以实现精确的轨迹跟踪。此外，文章还分析了LQR算法在ros_motion_planning运动规划库中的实现，通过源代码详解了误差量化、状态方程动态矩阵的建立、反馈控制增益的计算以及最终控制向量的生成等关
用霍夫变换算法来识别图像中圆形的轮廓cv::HoughCircles
追赶时代的博客
08-06 430
霍夫变换 圆形轮廓检测 cv::HoughCircles
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-09 290
其中a和b是用户传入的参数，函数返回的是两者中较大的数。
文本加密工具类-支持MD5、SHA1、SHA256、SHA224、SHA512、SHA384、SHA3、RIPMD160算法
张三博客
08-06 236
【代码】文本加密工具类-支持MD5、SHA1、SHA256、SHA224、SHA512、SHA384、SHA3、RIPMD160算法。
算法日记day 33（动归之斐波那契数|爬楼梯）
m0_74980681的博客
08-08 343
要求每次可以爬1阶或者2阶，逆向思维可以理解为，当我们上到最后一阶楼梯时，可以迈一阶楼梯dp[n-1]，或者迈两阶楼梯上dp[n-2]，因此可得最终爬上去n阶台阶的方法共有dp[n-1]+dp[n-2]种方法，dp的方法是爬到第n阶台阶总共有多少种方法，而不是走了几步，因此递推关系仍是斐波那契数列。已知斐波那契数列递推式为dp[i]=dp[i-1]+dp[i-2]，因此求第n个数只需要逐渐相加获得。1. 1 阶 + 1 阶 + 1 阶。1. 1 阶 + 1 阶。2. 1 阶 + 2 阶。
代码随想录算法训练营day37｜动态规划part05
qq_39065682的博客
08-08 215
感觉今天学的技巧性都挺强的，完全背包的还得再看看；
算法测试.
cxj0695的博客
08-06 385
现在，尼克需要在公司中建立一个 "主管-同级 "关系的树状层次结构(也就是说，除了一名员工外，每名员工都有一名主管)。有N种豆子，这些豆子只能靠颜色来区分，每个豆子都有它的美味度；题目要求的是每种颜色豆子里面的美味度最小值的最大值；题目意思就是给你t个字符串，让你找出每个串与codeforces这个串有多少不同的字母；贪心，把m条关系按照代价排序，当x的大于y的，且y没有主管即可能让x当y的主管；运用map来存储最小的美味度，然后循环遍历找最大的美味度就好；的主管，但需支付额外费用。
leetcode 560.和为k的子数组
m0_73917165的博客
08-09 221
我们求出来前缀和之后,其实也就是变相知道了某个区间的和,就如上面所说的,如果两个区间相减为k,那么我们只需要求出该前缀和-k存不存在有那么一个区间是刚刚成立的那个式子的值.逆向思维.思路二:前缀和.对于子序列问题,一般来说就会用到滑动窗口的双指针,以及前缀和这种思想.这里也是,前缀和对于子序列求解的本质其实就是对于各个区间相加减得到全部子区间的过程.思路一:可以仿照数据结构黑皮书中第一章演示最大子段和的做法,我们可以暴力求解,然后在暴力做法的基础上,边计算边判断,降低时间复杂度至O(n2).
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值