代码随想录算法训练营第十三天打卡

最新推荐文章于 2024-11-14 21:21:03 发布
最新推荐文章于 2024-11-14 21:21:03 发布
阅读量634 收藏
点赞数
文章标签： 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50649633/article/details/133066057
版权

102.二叉树的层序遍历

代码如下：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) { //方法一：广度遍历
        vector<vector<int>> ans;
        queue<TreeNode*> q;
        if (root == nullptr) {
            return ans;
        }
        q.push(root);
        while (!q.empty()) { //重要
            int size = q.size(); //由于队列q的大小会在每一次for循环之后变化，所以需要每次变更队列大小。
            vector<int> tempVec = {};
            for (int i = 0; i < size; i++) {
                TreeNode* tempNode = q.front();
                q.pop();
                tempVec.push_back(tempNode->val);
                if (tempNode->left) {
                    q.push(tempNode->left);
                }
                if (tempNode->right) {
                    q.push(tempNode->right);
                }
            }
            ans.push_back(tempVec);
        }
        return ans;
    }
};
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;
    }
};

107.二叉树的层次遍历2

代码如下：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) { //用广度遍历来做
        queue<TreeNode*> q;
        vector<vector<int>> ans;
        if (root == nullptr) {
            return ans;
        }
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            vector<int> temp;
            for (int i = 0; i < size; i++) {
                TreeNode* curr = q.front();
                temp.push_back(curr->val);
                q.pop();
                if (curr->left != nullptr) {
                    q.push(curr->left);
                }
                if (curr->right != nullptr) {
                    q.push(curr->right);
                }
            }
            ans.push_back(temp);
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

199.二叉树的右视图

代码如下：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) { //判断每次循环中是否为队列末尾的数，如果是，那就加入到vector中。
        vector<int> ans;
        queue<TreeNode*> q;
        if (root == nullptr) {
            return ans;
        }
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            for (int i = 0; i < size; i++) {
                TreeNode* curr;
                curr = q.front();
                q.pop();
                if (i == size - 1) {
                    ans.push_back(curr->val);
                }
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
        }
        return ans;
    }
};

637.二叉树的层平均值

代码如下：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> q;
        vector<double> ans;
        if (root == nullptr) {
            return ans;
        }
        q.push(root);
        while (!q.empty()) {
            double temp = 0;
            double avg = 0;
            int size = q.size();
            for (int i = 0; i < size; i++) {
                TreeNode* curr = q.front();
                q.pop();
                temp += curr->val;
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
            avg = temp / size;
            ans.push_back(avg);
        }
        return ans;
    }
};

429.N叉树的层序遍历

代码如下：

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*> q;
        vector<vector<int>> ans;
        if (root == nullptr) {
            return ans;
        }
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            vector<int> temp;
            for (int i = 0; i < size; i++) {
                Node* curr = q.front();
                q.pop();
                temp.push_back(curr->val);
                for (int j = 0; j < curr->children.size(); j++) {
                    if (curr->children[j]) {
                        q.push(curr->children[j]);
                    }
                }
            }
            ans.push_back(temp);
        }
        return ans;
    }
};

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

代码如下：

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> q;
        vector<int> ans;
        if (root == nullptr) {
            return ans;
        }
        q.push(root);
        while(!q.empty()) {
            int max = INT_MIN;
            int size = q.size();
            for (int i = 0; i < size; i++) {
                TreeNode* curr = q.front();
                q.pop();
                int temp = curr->val;
                if (temp > max) {
                    max = temp;
                }
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
            ans.push_back(max);
        }
        return ans;
    }
};

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

代码如下：

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();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

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

代码如下：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

104.二叉树的最大深度

代码如下：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> q;
        int depth = 0;
        if (root == nullptr) {
            return depth;
        }
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            if (size) {
                depth++;
            }
            for (int i = 0; i < size; i++) {
                TreeNode* curr = q.front();
                q.pop();
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
            }
        }
        return depth;
    }
};

111.二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> q;
        int depth = 0;
        if (root == nullptr) {
            return depth;
        }
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* curr = q.front();
                q.pop();
                if (curr->left) {
                    q.push(curr->left);
                }
                if (curr->right) {
                    q.push(curr->right);
                }
                if (curr->left == nullptr && curr->right == nullptr) {
                    return depth;
                }
            }
        }
        return depth;
    }
};

226.翻转二叉树

递归法代码如下：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) { //方法二：递归法
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

遍历法代码如下：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) { //方法一：迭代法
        stack<TreeNode*> st;
        if (root == nullptr) {
            return root;
        }
        st.push(root);
        while (!st.empty()) {
            TreeNode* curr = st.top();
            st.pop();
            swap(curr->left, curr->right);
            if (curr->left) {
                st.push(curr->left);
            }
            if (curr->right) {
                st.push(curr->right);
            }
        }
        return root;
    }
};

101.对称二叉树

递归法代码如下：

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) 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 = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        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;
    }
};

对称二叉树的代码写起来还是有困难，还要继续加油。

今毕。

qq_50649633
关注
代码随想录算法训练营打卡第一天
weixin_46724054的博客
03-01 1811
代码随想录算法训练营第1天 | Leetcode704 二分查找， 27 移除元素。
代码随想录算法训练营第三十四天 | LeetCode 51、37
Bingjiaokong的博客
01-30 1182
代码随想录刷题-day34
代码随想录算法训练营60天一刷总结：
qq_45865950的博客
05-14 1032
刷题小结
代码随想录算法训练营 个人总结
weixin_42286468的博客
07-09 1482
首刷代码随想录训练营，值得鼓励，个人小结一篇
代码随想录算法训练营第九天打卡
qq_50649633的博客
09-15 828
栈遵循先进后出原则(FILO)。而队列则是遵循先进先出原则(FIFL)。在C++中，通常用STL标准库中的stack容器实现栈，用queue容器来实现队列。使用两个队列实现栈的功能。
代码随想录算法训练营总结
m0_68682181的博客
02-20 674
正式结束了代码随想录算法训练营为期60天的打卡，最终能够坚持下来感觉还是很有成就感的。我作为一个大四保研结束转码的机械人，在推免结束后老师就给我发了代码随想录的网站让我学习算法，我在系统的复习完一遍C语言后初步学习了大致的C++语法，就开始了代码随想录的学习，大概学了半个月多的时间，在没有任何数据结构算法的基础下，学到了二叉树章节，即便有网课的讲解还是感到有些力不从心，没有坚持下去的动力，也是在偶然的情况下了解到了算法训练营并加入到打卡的队伍之中。
代码随想录算法训练营每日精华
栗少的博客
12-27 2537
以下为代码随想录算法训练营优质讨论内容 代码随想录算法训练营 以下为代码随想录算法训练营优质讨论内容 刷题建议 ●代码随想录目前有前半部分都有视频讲解，一定要先看视频，事半功倍。 ●一定要了解自己做题用的语言，或者说，原本可能不熟，但在做题过程中，碰到一些语法问题、容器选择问题等等，就随时地百度、google一下，这样刷题一圈下来，对语言的掌握程度也能提高不少 ●几乎所有的代码问题都可以通过打日志来解决，哪里不懂打哪里的日志。 ●如果对递归不是很熟悉, 就主要先学一下思想, 设计简单case, 进入到递归的
代码随想录算法训练营第十九天打卡
qq_50649633的博客
09-28 533
【代码】代码随想录算法训练营第十九天打卡。
代码随想录算法训练营第十天打卡
qq_50649633的博客
09-16 721
【代码】代码随想录算法训练营第十天打卡。
代码随想录算法训练营：15/60
Dustin_c的博客
06-25 1351
包含LC的几道题目，还有相应概念的补充。
代码随想录算法训练营第一天 - 704. 二分查找
05-08
代码随想录算法训练营第一天 - 704. 二分查找
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
10-12
代码随想录算法训练营第一天- 977.有序数组的平方 ， 209.长度最小的子数组，59.螺旋矩阵II
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
java计算文本相似度算法总结
sunsiny
11-14 530
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
16 合并区间
weixin_47521269的博客
11-12 725
【代码】16 合并区间。
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1080
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1507
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
每日小题--买股票的最佳时机
最新发布
m0_74977981的博客
11-14 441
毋庸置疑，一定需要数组遍历结束后才能确定这么一个买入点和卖出点，所以此时想要提升算法的话就要找到一个只需要遍历一遍就能出结果的方法，即将时间复杂度控制在O(n)；遍历数组的过程中去找数组中是否存在一个低价点，并且在低价点的基础上去判断有无上升空间；即杜绝了{4，3，2，1}的情况出现，买入后无法卖出。在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。后出价最高的一天卖出，简而言之，就是找到一个比起始小，并且结尾在一个有最大差距的位置；
算法每日双题精讲——滑动窗口（长度最小的子数组，无重复字符的最长子串）
A Charmer 的博客
11-11 1481
本文聚焦算法中的滑动窗口算法，通过“长度最小的子数组”和“无重复字符的最长子串”两道经典题目进行精讲。滑动窗口利用双指针界定动态窗口，在数组或字符串上滑动以求解。对于“长度最小的子数组”，初始化指针与变量，通过移动指针扩展与收缩窗口，找到满足和≥目标的最小子数组长度。“无重复字符的最长子串”则借助集合记录窗口内字符，根据字符重复性移动指针并更新最长子串长度。文章展示了滑动窗口算法在处理此类问题时的高效性与灵活性，文末还设置投票环节，引导读者思考算法关键难点，助力读者深入理解滑动窗口算法。
代码随想录算法训练营第二十二天
09-13
第二十二天的算法训练营主要涵盖了Leetcode题目中的三道题目，分别是Leetcode 28 "Find the Index of the First Occurrence in a String"，Leetcode 977 "有序数组的平方"，和Leetcode 209 "长度最小的子数组"。 首先是Leetcode 28题，题目要求在给定的字符串中找到第一个出现的字符的索引。思路是使用双指针来遍历字符串，一个指向字符串的开头，另一个指向字符串的结尾。通过比较两个指针所指向的字符是否相等来判断是否找到了第一个出现的字符。具体实现的代码如下： ```python def findIndex(self, s: str) -> int: left = 0 right = len(s) - 1 while left <= right: if s[left == s[right]: return left left += 1 right -= 1 return -1 ``` 接下来是Leetcode 977题，题目要求对给定的有序数组中的元素进行平方，并按照非递减的顺序返回结果。这里由于数组已经是有序的，所以可以使用双指针的方法来解决问题。一个指针指向数组的开头，另一个指针指向数组的末尾。通过比较两个指针所指向的元素的绝对值的大小来确定哪个元素的平方应该放在结果数组的末尾。具体实现的代码如下： ```python def sortedSquares(self, nums: List[int]) -> List[int]: left = 0 right = len(nums) - 1 ans = [] while left <= right: if abs(nums[left]) >= abs(nums[right]): ans.append(nums[left ** 2) left += 1 else: ans.append(nums[right ** 2) right -= 1 return ans[::-1] ``` 最后是Leetcode 209题，题目要求在给定的数组中找到长度最小的子数组，使得子数组的和大于等于给定的目标值。这里可以使用滑动窗口的方法来解决问题。使用两个指针来表示滑动窗口的左边界和右边界，通过移动指针来调整滑动窗口的大小，使得滑动窗口中的元素的和满足题目要求。具体实现的代码如下： ```python def minSubArrayLen(self, target: int, nums: List[int]) -> int: left = 0 right = 0 ans = float('inf') total = 0 while right < len(nums): total += nums[right] while total >= target: ans = min(ans, right - left + 1) total -= nums[left] left += 1 right += 1 return ans if ans != float('inf') else 0 ``` 以上就是第二十二天的算法训练营的内容。通过这些题目的练习，可以提升对双指针和滑动窗口等算法的理解和应用能力。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值