队列+宽搜（典型算法思想）—— OJ例题算法解析思路

最新推荐文章于 2025-11-01 21:57:43 发布
原创 最新推荐文章于 2025-11-01 21:57:43 发布 · 1.3k 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #leetcode #c++ #数据结构 #宽度优先

目录

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

算法代码： 

1. Node 类定义

2. Solution 类与层序遍历函数

3. 初始化结果与队列

4. 开始层序遍历

5. 返回结果

总结

改进建议

二、103. 二叉树的锯齿形层序遍历 - 力扣（LeetCode）

算法代码： 

1. TreeNode 类定义

2. Solution 类与锯齿形层序遍历函数

3. 初始化结果与队列

4. 开始层序遍历

5. 判断是否逆序

6. 返回结果

总结

改进建议

主要改进：

三、662. 二叉树最大宽度 - 力扣（LeetCode） 

算法代码：

1. TreeNode 类定义

2. Solution 类及其方法

3. 初始化结果与队列

4. 开始遍历树

5. 准备下一层节点

6. 返回结果

总结

改进建议

改动说明：

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

算法代码： 

1. TreeNode 类定义

2. Solution 类与方法

3. 初始化结果与队列

4. 开始遍历

5. 返回结果

总结

改进建议

主要改动

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

算法代码： 

/*
// 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>> ret; // 记录最终结果
        queue<Node*> q;          // 层序遍历需要的队列
        if (root == nullptr)
            return ret;
        q.push(root);
        while (q.size()) {
            int sz = q.size(); // 先求出本层元素的个数
            vector<int> tmp;   // 统计本层的节点
            for (int i = 0; i < sz; i++) {
                Node* t = q.front();
                q.pop();
                tmp.push_back(t->val);
                for (Node* child : t->children) // 让下⼀层结点⼊队
                {
                    if (child != nullptr)
                        q.push(child);
                }
            }
            ret.push_back(tmp);
        }
        return ret;
    }
};

1. 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;
    }
};

  • Node 类定义了 N 叉树的节点结构，每个节点包含一个整型值 val 和一个子节点向量 children，用于存储该节点的所有子节点。

  • 提供了三个构造函数：

    • 默认构造函数。

    • 接受一个值 _val 的构造函数。

    • 接受一个值和一个子节点向量的构造函数。

2. Solution 类与层序遍历函数

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {

  • 定义了 Solution 类，并在其中实现了 levelOrder 函数，该函数接受一个指向根节点的指针 root，并返回一个二维向量 vector<vector<int>>，表示层序遍历的结果。

3. 初始化结果与队列

vector<vector<int>> ret; // 记录最终结果
queue<Node*> q;          // 层序遍历需要的队列
if (root == nullptr)
    return ret;
q.push(root);

  • 创建一个向量 ret 用于存储每层的节点值。

  • 创建一个队列 q 用于实现 BFS。

  • 如果 root 为 nullptr（即树为空），直接返回空的结果。

  • 将根节点 root 入队。

4. 开始层序遍历

while (q.size()) {
    int sz = q.size(); // 先求出本层元素的个数
    vector<int> tmp;   // 统计本层的节点
    for (int i = 0; i < sz; i++) {
        Node* t = q.front();
        q.pop();
        tmp.push_back(t->val);
        for (Node* child : t->children) // 让下⼀层结点⼊队
        {
            if (child != nullptr)
                q.push(child);
        }
    }
    ret.push_back(tmp);
}

  • 使用 while 循环，当队列 q 不为空时继续遍历：

    • int sz = q.size(); 获取当前层节点的数量。

    • 创建一个临时向量 tmp 用于存储当前层的节点值。

    • 使用 for 循环遍历当前层的每个节点：

      • 从队列中取出当前节点 t（q.front()）并将其从队列中移除（q.pop()）。

      • 将节点 t 的值 t->val 添加到 tmp 中。

      • 遍历当前节点的所有子节点 t->children，将每个子节点（如果不为 nullptr）入队，以便在下一层处理。

    • 将当前层的结果 tmp 添加到最终结果 ret 中。

5. 返回结果

return ret;

  • 最后，返回包含所有层节点值的二维向量 ret。

总结

        这段代码实现了 N 叉树的层序遍历，时间复杂度为 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。空间复杂度为 O(m)，其中 m 是树的最大宽度，因为在最坏情况下（例如完全平衡树），队列中可能会存储大量节点。

改进建议

  1. 使用更现代的 C++ 特性：可以使用 nullptr 代替 NULL（虽然这里已经用了），同时可以使用 auto 关键字来简化代码。

  2. 检查子节点是否为 nullptr：在此实现中，假设所有的子节点都已初始化为有效指针。如果子节点可以为 nullptr，则应确保在入队之前检查它们。

  3. 代码整洁性：可以考虑进一步提高代码的可读性，例如使用更具描述性的变量名。

以下是改进后的代码示例：

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> ret; // 记录最终结果
        queue<Node*> q;          // 层序遍历需要的队列
        
        if (root == nullptr) return ret; // 空树直接返回
        
        q.push(root); // 将根节点入队
        
        while (!q.empty()) {
            int sz = q.size(); // 当前层节点数
            vector<int> tmp;   // 存储当前层的节点值
            
            for (int i = 0; i < sz; i++) {
                Node* t = q.front(); // 获取队头节点
                q.pop();              // 出队
                tmp.push_back(t->val); // 加入当前层结果
                
                for (Node* child : t->children) { // 遍历子节点
                    if (child) q.push(child); // 非空子节点入队
                }
            }
            
            ret.push_back(tmp); // 添加当前层结果
        }
        
        return ret; // 返回结果
    }
};

二、103. 二叉树的锯齿形层序遍历 - 力扣（LeetCode）

算法代码： 

/**
 * 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>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        if (root == nullptr)
            return ret;
        queue<TreeNode*> q;
        q.push(root);
        int level = 1;
        while (q.size()) {
            int sz = q.size();
            vector<int> tmp;
            for (int i = 0; i < sz; i++) {
                auto t = q.front();
                q.pop();
                tmp.push_back(t->val);
                if (t->left)
                    q.push(t->left);
                if (t->right)
                    q.push(t->right);
            }
            // 判断是否逆序
            if (level % 2 == 0)
                reverse(tmp.begin(), tmp.end());
            ret.push_back(tmp);
            level++;
        }
        return ret;
    }
};

1. TreeNode 类定义

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

  • TreeNode 结构体定义了二叉树的节点，包含一个整型值 val 和指向左、右子节点的指针 left 和 right。

  • 提供了三个构造函数：

    • 默认构造函数，初始化一个值为 0 的节点。

    • 只接受一个整型值 x 的构造函数。

    • 接受一个值以及左右子节点的构造函数。

2. Solution 类与锯齿形层序遍历函数

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {

  • 定义了 Solution 类，并在其中实现了 zigzagLevelOrder 函数，该函数接受一个指向根节点的指针 root，并返回一个二维向量 vector<vector<int>>，表示锯齿形遍历的结果。

3. 初始化结果与队列

vector<vector<int>> ret;
if (root == nullptr)
    return ret;
queue<TreeNode*> q;
q.push(root);
int level = 1;

  • 创建一个向量 ret 用于存储每层的节点值。

  • 检查根节点 root 是否为 nullptr，如果是，直接返回空的结果。

  • 创建一个队列 q 用于实现层序遍历，并将根节点 root 入队。

  • 初始化层计数器 level，初始值为 1。

4. 开始层序遍历

while (q.size()) {
    int sz = q.size();
    vector<int> tmp;
    for (int i = 0; i < sz; i++) {
        auto t = q.front();
        q.pop();
        tmp.push_back(t->val);
        if (t->left)
            q.push(t->left);
        if (t->right)
            q.push(t->right);
    }

  • 使用 while 循环，当队列 q 不为空时继续遍历：

    • 获取当前层节点的数量 sz。

    • 创建一个临时向量 tmp 用于存储当前层的节点值。

    • 使用 for 循环遍历当前层的每个节点：

      • 从队列中取出当前节点 t（q.front()）并将其从队列中移除（q.pop()）。

      • 将节点 t 的值 t->val 添加到 tmp 中。

      • 将当前节点的左右子节点（如果存在）入队，以便在下一层处理。

5. 判断是否逆序

if (level % 2 == 0)
    reverse(tmp.begin(), tmp.end());
ret.push_back(tmp);
level++;

  • 检查当前层的层数 level 是否为偶数：

    • 如果是偶数层，则使用 reverse 函数反转 tmp 中的元素，以实现从右到左的输出。

  • 将当前层的结果 tmp 添加到最终结果 ret 中。

  • 增加层计数器 level。

6. 返回结果

return ret;

  • 最后，返回包含所有层节点值的二维向量 ret。

总结

        这段代码实现了对二叉树的锯齿形层序遍历，时间复杂度为 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。空间复杂度为 O(m)，其中 m 是树的最大宽度，因为在最坏情况下（例如完全平衡树），队列中可能会存储大量节点。

改进建议

  1. 使用更现代的 C++ 特性：可以使用 nullptr 代替 NULL（虽然这里已经用了），同时可以使用 auto 关键字来简化代码。

  2. 优化反转操作：如果使用双端队列（deque），可以避免在偶数层时反转数组的开销，直接在队列的两端插入元素。

  3. 代码整洁性：可以考虑进一步提高代码的可读性，例如使用更具描述性的变量名。

以下是稍作修改和优化后的代码示例，使用双端队列来提高效率：

#include <vector>
#include <queue>
#include <deque> // 引入双端队列
using namespace std;

// 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>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        if (root == nullptr)
            return ret;

        queue<TreeNode*> q;
        q.push(root);
        bool leftToRight = true; // 指示当前层是否从左到右

        while (!q.empty()) {
            int sz = q.size();
            deque<int> tmp; // 使用双端队列保存当前层节点值
            
            for (int i = 0; i < sz; i++) {
                auto t = q.front();
                q.pop();
                
                if (leftToRight) {
                    tmp.push_back(t->val); // 从右侧插入
                } else {
                    tmp.push_front(t->val); // 从左侧插入
                }
                
                if (t->left)
                    q.push(t->left);
                if (t->right)
                    q.push(t->right);
            }
            
            ret.push_back(vector<int>(tmp.begin(), tmp.end())); // 将 deque 转换为 vector
            leftToRight = !leftToRight; // 切换方向
        }
        
        return ret;
    }
};

主要改进：

  • 使用 deque 替代 vector，避免在偶数层时反转数组，提高了效率。

  • 使用 leftToRight 布尔变量来指示当前层的遍历方向，使代码更清晰。

三、662. 二叉树最大宽度 - 力扣（LeetCode） 

不采用下面硬来的方法，会超时： 

算法代码：

/**
 * 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 widthOfBinaryTree(TreeNode* root) {
        vector<pair<TreeNode*, unsigned int>> q; // ⽤数组模拟队列
        q.push_back({root, 1});
        unsigned int ret = 0;
        while (q.size()) {
            // 先更新这⼀层的宽度
            auto& [x1, y1] = q[0];
            auto& [x2, y2] = q.back();
            ret = max(ret, y2 - y1 + 1);
            // 让下⼀层进队
            vector<pair<TreeNode*, unsigned int>> tmp; // 让下⼀层进⼊这个队列
            for (auto& [x, y] : q) {
                if (x->left)
                    tmp.push_back({x->left, y * 2});
                if (x->right)
                    tmp.push_back({x->right, y * 2 + 1});
            }
            q = tmp;
        }
        return ret;
    }
};

1. TreeNode 类定义

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

  • TreeNode 结构体定义了二叉树的节点。每个节点包含一个整型值 val 和指向左、右子节点的指针 left 和 right。

  • 包含构造函数，用于不同情况初始化节点。

2. Solution 类及其方法

class Solution {
public:
    int widthOfBinaryTree(TreeNode* root) {

  • 定义了 Solution 类，并在其中实现了 widthOfBinaryTree 方法，该方法接受一个指向根节点 root 的指针，并返回树的最大宽度。

3. 初始化结果与队列

vector<pair<TreeNode*, unsigned int>> q; // 用数组模拟队列
q.push_back({root, 1}); // 用一个编号表示根节点
unsigned int ret = 0; // 记录最大宽度

  • 创建一个向量 q，用来存储二叉树节点及其相对位置（编号）：

    • pair<TreeNode*, unsigned int> 表示节点和其编号，编号用于计算宽度。

  • 将根节点和编号 1 入队。

  • 初始化 ret 为 0，用于保存最大宽度。

4. 开始遍历树

while (q.size()) {
    // 先更新这层的宽度
    auto& [x1, y1] = q[0];
    auto& [x2, y2] = q.back();
    ret = max(ret, y2 - y1 + 1);

  • 使用 while 循环，直到队列 q 为空：

    • 取出当前层的第一个节点 x1 和它的编号 y1，以及最后一个节点 x2 和它的编号 y2。

    • 通过计算 y2 - y1 + 1 更新最大宽度 ret。

5. 准备下一层节点

vector<pair<TreeNode*, unsigned int>> tmp; // 让下一层进队
for (auto& [x, y] : q) {
    if (x->left)
        tmp.push_back({x->left, y * 2}); // 左子节点的编号是父节点编号的两倍
    if (x->right)
        tmp.push_back({x->right, y * 2 + 1}); // 右子节点的编号是父节点编号的两倍加一
}
q = tmp; // 更新当前队列为下一层的节点

  • 创建一个临时向量 tmp 用于存储下一层的节点及其相对位置。

  • 遍历当前层的节点：

    • 如果节点 x 有左子节点，将其和对应的编号（y * 2）入队。

    • 如果节点 x 有右子节点，将其和对应的编号（y * 2 + 1）入队。

  • 更新队列 q 为 tmp，以便在下一次循环中处理下一层。

6. 返回结果

return ret;

  • 最后，返回最大宽度 ret。

总结

        这段代码有效地计算了二叉树的最大宽度，时间复杂度为 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。空间复杂度为 O(m)，其中 m 是树的最大宽度，最坏情况下队列可能存储一层的所有节点。

改进建议

  1. 内存管理：虽然此实现会使用较少的内存，但在某些情况下，可以考虑使用队列（如 std::queue）而不是向量来管理节点，以提高效率和可读性。

  2. 错误处理：可以增加对无效输入（如空树）的处理逻辑。

  3. 代码可读性：在 C++17 及以上，可以使用 std::optional 或其他特性来进一步改善代码的表达力。

以下是稍作修改后的代码示例，使用 std::queue 来模拟队列，增强可读性：

#include <queue>
#include <utility> // 引入 std::pair
using namespace std;

// 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 widthOfBinaryTree(TreeNode* root) {
        if (root == nullptr) return 0; // 检查空树的情况

        queue<pair<TreeNode*, unsigned int>> q; // 使用队列
        q.push({root, 1}); // 根节点入队并设置初始编号
        unsigned int ret = 0; // 记录最大宽度
        
        while (!q.empty()) {
            int sz = q.size();
            auto [x1, y1] = q.front(); // 当前层第一个节点
            auto [x2, y2] = q.back();  // 当前层最后一个节点
            ret = max(ret, y2 - y1 + 1); // 更新最大宽度
            
            // 将下一层的节点和它们的编号入队
            for (int i = 0; i < sz; i++) {
                auto [x, y] = q.front();
                q.pop();
                if (x->left) q.push({x->left, y * 2});
                if (x->right) q.push({x->right, y * 2 + 1});
            }
        }
        
        return ret; // 返回结果
    }
};

改动说明：

  • 使用 std::queue 来管理节点，而不是使用向量，增强了代码的可读性和逻辑清晰度。

  • 添加了对空树的处理逻辑。

 

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

算法代码： 

/**
 * 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> ret;
        if (root == nullptr)
            return ret;
        queue<TreeNode*> q;
        q.push(root);
        while (q.size()) {
            int sz = q.size();
            int tmp = INT_MIN;
            for (int i = 0; i < sz; i++) {
                auto t = q.front();
                q.pop();
                tmp = max(tmp, t->val);
                if (t->left)
                    q.push(t->left);
                if (t->right)
                    q.push(t->right);
            }
            ret.push_back(tmp);
        }
        return ret;
    }
};

1. TreeNode 类定义

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

  • TreeNode 结构体定义了二叉树的节点，每个节点包含一个整型值 val 以及指向左、右子节点的指针 left 和 right。

  • 提供了三个构造函数，使得节点的创建更加灵活。

2. Solution 类与方法

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {

  • Solution 类中的 largestValues 方法接收一个指向根节点 root 的指针，并返回一个整型向量 vector<int>，其中包含每一层的最大值。

3. 初始化结果与队列

vector<int> ret;
if (root == nullptr)
    return ret; // 如果树为空，返回空向量
queue<TreeNode*> q;
q.push(root); // 将根节点入队

  • 创建一个向量 ret 用于存储每层的最大值。

  • 检查根节点 root 是否为 nullptr，如果是，直接返回空向量。

  • 创建一个队列 q 用于执行广度优先搜索，并将根节点 root 入队。

4. 开始遍历

while (q.size()) {
    int sz = q.size(); // 当前层的节点数量
    int tmp = INT_MIN; // 用于存储当前层的最大值
    for (int i = 0; i < sz; i++) {
        auto t = q.front(); // 获取队头节点
        q.pop();            // 出队
        tmp = max(tmp, t->val); // 更新当前层的最大值
        if (t->left)
            q.push(t->left); // 左子节点入队
        if (t->right)
            q.push(t->right); // 右子节点入队
    }
    ret.push_back(tmp); // 将当前层的最大值加入结果
}

  • 使用 while 循环，当队列 q 不为空时继续遍历：

    • 获取当前层的节点数量 sz。

    • 初始化 tmp 为 INT_MIN，用于存储当前层的最大值。

    • 使用一个 for 循环遍历当前层的每个节点：

      • 取出队头节点 t，并将其从队列中移除。

      • 使用 max 函数更新当前层的最大值 tmp。

      • 如果当前节点有左子节点，将其入队。

      • 如果当前节点有右子节点，将其入队。

    • 在每次完成当前层遍历后，将最大值 tmp 添加到结果向量 ret。

5. 返回结果

return ret;

  • 最后，返回包含每层最大值的向量 ret。

总结

这段代码有效地找出了每一层的最大值，时间复杂度为 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。空间复杂度为 O(m)，其中 m 是树的最大宽度，因为在最坏情况下队列中可能存储一层的所有节点。

改进建议

  1. 使用范围 for 循环：可以使用范围 for 循环来简化代码，使代码更清晰。

  2. 处理无效输入：可以更明确地处理空树的情况，虽然当前实现已经涵盖了这点。

  3. 使用 nullptr：在 C++11 及以上，使用 nullptr 代替 NULL。

以下是稍作修改后的代码示例，使用范围 for 循环：

#include <vector>
#include <queue>
#include <limits.h> // 引入 INT_MIN
using namespace std;

// 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> ret;
        if (root == nullptr)
            return ret; // 如果树为空，返回空向量
        
        queue<TreeNode*> q;
        q.push(root); // 将根节点入队
        
        while (!q.empty()) {
            int sz = q.size(); // 当前层的节点数量
            int tmp = INT_MIN; // 当前层的最大值
            
            for (int i = 0; i < sz; i++) {
                auto t = q.front(); // 获取队头节点
                q.pop();            // 出队
                tmp = max(tmp, t->val); // 更新最大值
                
                if (t->left) 
                    q.push(t->left); // 左子节点入队
                if (t->right)
                    q.push(t->right); // 右子节点入队
            }
            ret.push_back(tmp); // 将当前层的最大值加入结果
        }
        
        return ret; // 返回结果
    }
};

主要改动

  • 增加了代码的可读性和整洁度，保持了功能的一致性。

浅谈迷宫搜索类的双向bfs问题(例题解析)
bigsai
02-15 5925
前言 在搜索问题中，以迷宫问题最具有代表性，无论是八皇后的回溯问题，还是dfs找出口，bfs找最短次数等等题目的问题。在我们刚开始ac的时候、可能有着很多满足感！感觉是个迷宫问题咱么都可以给他这么搜出来 ！！ 然而，当数据达到一定程度，我们使用简单的方法肯定会爆炸的，****。就可能需要一些特殊的巧妙方法处理，比如各种剪枝、优先队列、A*、dfs套bfs，又或者利用一些非常厉害的数学方法比如康托...
夜深人静写算法（十九）- 背包总览
热门推荐
英雄哪里出来
01-22 7万+
背包问题，你学废了吗？
FloodFill 算法（典型算法思想）—— OJ例题算法解析思路
祯的博客
03-02 1241
FloodFill 算法（典型算法思想）—— OJ例题算法解析思路
链表（典型算法思想）—— OJ例题算法解析思路
祯的博客
02-15 1242
链表（典型算法思想）—— OJ例题算法解析思路
多源BFS（典型算法思想）—— OJ例题算法解析思路
祯的博客
02-24 1430
多源BFS（典型算法思想）—— OJ例题算法解析思路
BFS 解决 拓扑排序（典型算法思想）—— OJ例题算法解析思路
祯的博客
02-25 1145
BFS 解决 拓扑排序（典型算法思想）—— OJ例题算法解析思路
BFS 解决 FloodFill 算法（典型算法思想）—— OJ例题算法解析思路
祯的博客
02-21 1203
BFS 解决 FloodFill 算法（典型算法思想）—— OJ例题算法解析思路
BFS算法解决最短路径问题（典型算法思想）—— OJ例题算法解析思路
祯的博客
02-23 1486
BFS算法解决最短路径问题（典型算法思想）—— OJ例题算法解析思路
优先队列（典型算法思想）—— OJ例题算法解析思路
祯的博客
02-20 1340
优先队列（典型算法思想）—— OJ例题算法解析思路
算法进阶——贪心算法
2301_81296146的博客
03-04 394
每一步都选择局部最优解，而尽量不考虑对后续的影响，最终达到全局最优解。贪心的局限性：贪心算法不能保证获得全局最优解，但在默写问题上具有高效性。贪心的特征：贪心选择性质，最优子结构性质贪心的类型多而杂，难以划分，需要不断的练习与积累。
算法学习（七）—— 分治
aaqq800520的博客
11-03 1171
分治，就是“分而治之”的意思，就是把一个大问题，转化为若干个相同或者相似的几个子问题，然后在子问题的基础上再进行划分，直到能够快速一个子问题时停止划分我们的快速排序和归并排序就是典型的分治思想。
掌握ACM编程技巧——浙大OJ 700例题解析
标题和描述中提到的“ACM 浙大 700例题”，指的是浙江大学参与的ACM国际大学生程序设计竞赛（ACM-ICPC）所使用的在线测评系统ZOJ（Zhejiang University Online Judge）的700个练习题目以及相应的题解。ACM-ICPC是...
数据结构_算法_清华OJ_满分解题参考_1741868457.zip
03-14
本压缩包中的内容聚焦于数据结构与算法在清华大学在线评测系统（简称清华OJ）上的应用，旨在为学习者提供解题思路和满分解决方案的参考。 首先，数据结构是解决问题的工具，良好的数据结构设计能够显著提高算法的...
算法学习 18
t2786024916的博客
10-30 295
给你一个 32 位的有符号整数x，返回将x中的数字部分反转后的结果。如果反转后整数超过 32 位的有符号整数的范围，就返回 0。
Comparator 比较器 算法排序工具
prosperity__的博客
10-28 361
本文详细讲解了比较器的用法，又通过一个简单的案例以生动形象的语言帮助学者对比较器进行详细的了解。
RLHF 大模型对齐算法“填坑”史：从 PPO 的痛，到 DAPO
qq_63894862的博客
10-30 661
PPO是请了 4 个私教（模型）全方位辅导，效果好但学费极其昂贵。DPO是直接刷《五年高考三年模拟》，只看标准答案，效率高但缺乏举一反三的能力。GRPO是搞“学习小组”，大家互相批改作业，比平均分好的受表扬，既省了老师又保持了竞争。DAPO则是升级版的“精英学习小组”，只攻坚难题，并且鼓励尖子生“抢跑”。
《算法通关指南：数据结构和算法篇 --- 顺序表相关算法题》--- 1.询问学号，2.寄包柜，3.合并两个有序数组
最新发布
小龙报的博客
11-01 695
这篇文章介绍了三个与顺序表相关的算法题目： 询问学号 题目要求学生查询指定位置的学号，通过数组或vector直接存储学号实现快速查询，时间复杂度O(1)。 寄包柜 题目需要处理不定大小的二维数据，利用vector动态扩容特性解决传统数组空间不足的问题，通过resize实现按需分配。 合并有序数组 使用双指针法和辅助数组temp，依次比较两个数组元素并按序合并，最后将结果复制回原数组，时间复杂度O(m+n)。 文章强调算法竞赛中时间效率优先的思路，提供了数组和vector两种实现方式，并通过图示和代码注释帮助
最小调整顺序次数
y245166349的专栏
10-31 350
小A依次执行2n个指令往队列中添加数据和移出数据。其中n个指令是添加数据（可能从头部添加、也可能从尾部添加），依次添加1到n；n个指令是移出数据。有一个特异性的双端队列，该队列可以从头部或尾部添加数据，但是只能从头部移出数据。另外 n 行为移出数据指令，指令为："remove" 的形式，表示移出1个数据；请问 小A 最少需要调整几次才能够满足移除数据的顺序正好是1到n；为了满足最后输出的要求，小A可以在任何时候调整队列中数据的顺序。现在要求移除数据的顺序为1到n。一行一个数据n，表示数据的范围。
leetcode375.猜数字大小II
weixin_74175349的博客
10-29 220
【代码】leetcode375.猜数字大小II。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值