C++手撕基于ID3算法的决策树

最新推荐文章于 2026-06-17 23:49:13 发布
原创 最新推荐文章于 2026-06-17 23:49:13 发布 · 1.3k 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#算法 #决策树 #机器学习 #c++

背景

        书接上回，完成了KNN之后，小H又继续学习机器学习相关内容，这一次看到的是决策树，构建一个棵树来进行分类任务，确实是非常形象呢。

概念

        决策树是一种监督学习算法，常用于分类任务。ID3 算法通过计算信息增益来选择最优特征进行分裂，最终生成一棵树状结构，内部节点表示一个特征/属性，叶子节点表示一个类别。信息增益是信息论中的一个概念，用于衡量某个特征分裂数据集前后信息的减少量。

        ID3 算法的核心是信息增益（Information Gain），即通过计算每个特征对数据集分类的 “贡献度”，选择贡献度最大的特征作为当前节点的划分依据，直至所有样本被正确分类或无法继续划分。

关键概念

  1. 信息熵（Entropy） 信息熵是衡量数据集 “混乱程度” 的指标，熵值越高，数据越混乱（分类越不明确）。 

  2. 条件熵（Conditional Entropy） 当用特征A划分数据集D时，划分后的数据子集的平均信息熵称为条件熵。

  3. 信息增益（Information Gain） 信息增益是 “原始数据集的熵” 与 “按特征A划分后的条件熵” 的差值，衡量特征A对分类的贡献。信息增益越大，说明用特征A划分后的数据 “混乱程度降低越多”，该特征越适合作为当前节点的划分依据。

（以上几种公式就可以自行搜索）

ID3 算法流程

  1. 初始化：将所有训练样本作为根节点的数据集。
  2. 终止条件判断：
    • 若当前数据集所有样本属于同一类别，将该节点标记为叶节点，返回类别。
    • 若没有剩余特征可划分，将该节点标记为叶节点，返回样本中占比最高的类别（多数表决）。
  3. 选择最优特征：
    • 计算当前数据集的信息熵H(D)。
    • 对每个未使用的特征A，计算其信息增益Gain(D,A)。
    • 选择信息增益最大的特征A作为当前节点的划分特征。
  4. 划分数据集：
    • 按特征A的所有取值，将数据集拆分为多个子集D_j（每个取值对应一个子集）。
    • 为每个子集创建子节点，递归执行步骤 2-4，直至满足终止条件。

数据准备

        就假设我们有某个数据集，列名是：Age、income、Marital Status、Label，然后若干行吧。

数据结构

        我们将整个决策树封装到DecisionTree类中。

DecisionTree类

class DecisionTree{
public:
    // 节点类型枚举
    enum class NodeType{
        INTERNAL,
        LEAF
    };
    
    // 节点结构
    struct Node{
        NodeType type;
        std::string feature;
        std::map<std::string, std::unique_ptr<Node>> children;
        std::optional<std::string> label;
    };

    void fit(const Dataset& data, const std::vector<std::string>& features);
    std::string predict(const Example& example) const;

private:
    std::unique_ptr<Node> build_tree(const Dataset& data, const std::vector<std::string>& features);
    double entropy(const Dataset& data) const;
    double information_gain(const Dataset& data, const std::string& feature) const;
    std::string choose_best_feature(const Dataset& data, const std::vector<std::string>& features) const;
    std::string get_feature_value(const Example& example, const std::string& feature) const;
    
    std::unique_ptr<Node> root_;
    std::string predict_helper(const Node* node, const Example& example) const;
};

方法实现

计算熵

// 计算熵
double DecisionTree::entropy(const Dataset& data) const {
    if (data.empty()) return 0.0;

    std::unordered_map<std::string, int> label_counts;
    for (const auto& ex : data) {
        label_counts[ex.label]++;
    }

    double total = static_cast<double>(data.size());
    double entropy_value = 0.0;

    for (const auto& [label, count] : label_counts) {
        double p = static_cast<double>(count) / total;
        if (p > 0) { // 避免 log(0)
            entropy_value -= p * std::log2(p);
        }
    }
    return entropy_value;
}

计算信息增益

// 计算信息增益
double DecisionTree::information_gain(const Dataset& data, const std::string& feature) const {
    double initial_entropy = entropy(data);
    double weighted_entropy = 0.0;

    std::map<std::string, Dataset> split_data;
    for (const auto& ex : data) {
        std::string feature_value = get_feature_value(ex, feature);
        split_data[feature_value].push_back(ex);
    }

    for (const auto& [value, subset] : split_data) {
        double weight = static_cast<double>(subset.size()) / data.size();
        weighted_entropy += weight * entropy(subset);
    }

    return initial_entropy - weighted_entropy;
}

选择最佳特征

// 选择最佳特征
std::string DecisionTree::choose_best_feature(const Dataset& data, const std::vector<std::string>& features) const {
    double max_gain = -1.0;
    std::string best_feature;

    std::cout << "  Information gains:" << std::endl;
    for (const auto& feature : features) {
        double gain = information_gain(data, feature);
        std::cout << "    " << feature << ": " << gain << std::endl;
        if (gain > max_gain) {
            max_gain = gain;
            best_feature = feature;
        }
    }
    std::cout << "  Best feature: " << best_feature << " (gain: " << max_gain << ")" << std::endl;
    return best_feature;
}

构建决策树

// 递归构建决策树
std::unique_ptr<DecisionTree::Node> DecisionTree::build_tree(const Dataset& data, const std::vector<std::string>& features) {
    if (data.empty()) {
        return nullptr;
    }

    // 统计标签
    std::unordered_map<std::string, int> label_counts;
    for (const auto& ex : data) {
        label_counts[ex.label]++;
    }

    // 如果所有样本都属于同一类，创建叶子节点
    if (label_counts.size() == 1) {
        auto node = std::make_unique<Node>();
        node->type = NodeType::LEAF;
        node->label = label_counts.begin()->first;
        return node;
    }

    // 如果没有更多特征可用，选择最常见的标签
    if (features.empty()) {
        auto most_common_label = std::max_element(label_counts.begin(), label_counts.end(),
            [](const auto& a, const auto& b) {
                return a.second < b.second;
            });
        auto node = std::make_unique<Node>();
        node->type = NodeType::LEAF;
        node->label = most_common_label->first;
        return node;
    }

    // 选择最佳特征
    std::string best_feature = choose_best_feature(data, features);
    auto node = std::make_unique<Node>();
    node->type = NodeType::INTERNAL;
    node->feature = best_feature;

    // 调试信息：显示选择的最佳特征
    std::cout << "Selected best feature: " << best_feature << " for " << data.size() << " samples" << std::endl;

    // 按最佳特征分割数据
    std::map<std::string, Dataset> split_data;
    for (const auto& ex : data) {
        std::string feature_value = get_feature_value(ex, best_feature);
        split_data[feature_value].push_back(ex);
    }

    // 创建剩余特征列表
    std::vector<std::string> remaining_features;
    for (const auto& feature : features) {
        if (feature != best_feature) {
            remaining_features.push_back(feature);
        }
    }

    // 递归构建子树
    for (const auto& [value, subset] : split_data) {
        node->children[value] = build_tree(subset, remaining_features);
    }

    return node;
}

预测

// 预测函数
std::string DecisionTree::predict(const Example& example) const {
    if (!root_) {
        throw std::runtime_error("Decision tree has not been trained");
    }
    return predict_helper(root_.get(), example);
}

// 辅助预测函数
std::string DecisionTree::predict_helper(const Node* node, const Example& example) const {
    if (node->type == NodeType::LEAF) {
        return node->label.value();
    }

    const std::string& feature = node->feature;
    std::string feature_value = get_feature_value(example, feature);

    auto it = node->children.find(feature_value);
    if (it == node->children.end()) {
        throw std::runtime_error("Feature value '" + feature_value + "' not found in tree for feature '" + feature + "'");
    }

    return predict_helper(it->second.get(), example);
}

代码

        主要功能就在下面，下面附上一份完整代码，包括一些辅助功能函数的实现已经在main函数里面的简单测试：

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <optional>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <memory>
#include <cassert>

struct Example{
    int age;
    std::string income;
    std::string marital_status;
    std::string label;
};

using Dataset = std::vector<Example>;

class DecisionTree{
public:
    // 节点类型枚举
    enum class NodeType{
        INTERNAL,
        LEAF
    };
    
    // 节点结构
    struct Node{
        NodeType type;
        std::string feature;
        std::map<std::string, std::unique_ptr<Node>> children;
        std::optional<std::string> label;
    };

    void fit(const Dataset& data, const std::vector<std::string>& features);
    std::string predict(const Example& example) const;

private:
    std::unique_ptr<Node> build_tree(const Dataset& data, const std::vector<std::string>& features);
    double entropy(const Dataset& data) const;
    double information_gain(const Dataset& data, const std::string& feature) const;
    std::string choose_best_feature(const Dataset& data, const std::vector<std::string>& features) const;
    std::string get_feature_value(const Example& example, const std::string& feature) const;
    
    std::unique_ptr<Node> root_;
    std::string predict_helper(const Node* node, const Example& example) const;
};

// 计算熵
double DecisionTree::entropy(const Dataset& data) const{
    if(data.empty()) return 0.0;
    
    std::unordered_map<std::string,int> label_counts;
    for(const auto& ex : data){
        label_counts[ex.label]++;
    }
    
    double total = static_cast<double>(data.size());
    double entropy_value = 0.0;

    for(const auto& [label, count] : label_counts){
        double p = static_cast<double>(count) / total;
        if(p > 0) { // 避免log(0)
            entropy_value -= p * std::log2(p);
        }
    }
    return entropy_value;
}

// 获取特征值的辅助函数
std::string DecisionTree::get_feature_value(const Example& example, const std::string& feature) const{
    if(feature == "income"){
        return example.income;
    }
    else if(feature == "marital_status"){
        return example.marital_status;
    }
    else if(feature == "age"){
        if(example.age < 30){
            return "young";
        }
        else if(example.age >= 30 && example.age < 50){
            return "middle";
        }
        else{
            return "old";
        }
    }
    else{
        throw std::runtime_error("Unknown feature: " + feature);
    }
}

// 计算信息增益
double DecisionTree::information_gain(const Dataset& data, const std::string& feature) const{
    double initial_entropy = entropy(data);
    double weighted_entropy = 0.0;

    std::map<std::string, Dataset> split_data;
    for(const auto& ex : data){
        std::string feature_value = get_feature_value(ex, feature);
        split_data[feature_value].push_back(ex);
    }

    for(const auto& [value, subset] : split_data){
        double weight = static_cast<double>(subset.size()) / data.size();
        weighted_entropy += weight * entropy(subset);
    }

    return initial_entropy - weighted_entropy;
}

// 选择最佳特征
std::string DecisionTree::choose_best_feature(const Dataset& data, const std::vector<std::string>& features) const{
    double max_gain = -1.0;
    std::string best_feature;

    std::cout << "  Information gains:" << std::endl;
    for(const auto& feature : features){
        double gain = information_gain(data, feature);
        std::cout << "    " << feature << ": " << gain << std::endl;
        if(gain > max_gain){
            max_gain = gain;
            best_feature = feature;
        }
    }
    std::cout << "  Best feature: " << best_feature << " (gain: " << max_gain << ")" << std::endl;
    return best_feature;
}

std::unique_ptr<DecisionTree::Node> DecisionTree::build_tree(const Dataset& data, const std::vector<std::string>& features){
    if(data.empty()){
        return nullptr;
    }
    
    // 统计标签
    std::unordered_map<std::string, int> label_counts;
    for(const auto& ex : data){
        label_counts[ex.label]++;
    }
    
    // 如果所有样本都属于同一类，创建叶子节点
    if(label_counts.size() == 1){
        auto node = std::make_unique<Node>();
        node->type = NodeType::LEAF;
        node->label = label_counts.begin()->first;
        return node;
    }

    // 如果没有更多特征可用，选择最常见的标签
    if(features.empty()){
        auto most_common_label = std::max_element(label_counts.begin(), label_counts.end(),
            [](const auto& a, const auto& b){
                return a.second < b.second;
            });
        auto node = std::make_unique<Node>();
        node->type = NodeType::LEAF;
        node->label = most_common_label->first;
        return node;
    }

    // 选择最佳特征
    std::string best_feature = choose_best_feature(data, features);
    auto node = std::make_unique<Node>();
    node->type = NodeType::INTERNAL;
    node->feature = best_feature;
    
    // 调试信息：显示选择的最佳特征
    std::cout << "Selected best feature: " << best_feature << " for " << data.size() << " samples" << std::endl;

    // 按最佳特征分割数据
    std::map<std::string, Dataset> split_data;
    for(const auto& ex : data){
        std::string feature_value = get_feature_value(ex, best_feature);
        split_data[feature_value].push_back(ex);
    }
    
    // 创建剩余特征列表
    std::vector<std::string> remaining_features;
    for(const auto& feature : features){
        if(feature != best_feature){
            remaining_features.push_back(feature);
        }
    }
    
    // 递归构建子树
    for(const auto& [value, subset] : split_data){
        node->children[value] = build_tree(subset, remaining_features);
    }
    
    return node;
}

void DecisionTree::fit(const Dataset& data, const std::vector<std::string>& features){
    root_ = build_tree(data, features);
}

std::string DecisionTree::predict(const Example& example) const{
    if(!root_){
        throw std::runtime_error("Decision tree has not been trained");
    }
    return predict_helper(root_.get(), example);
}

std::string DecisionTree::predict_helper(const Node* node, const Example& example) const{
    if(node->type == NodeType::LEAF){
        return node->label.value();
    }

    const std::string& feature = node->feature;
    std::string feature_value = get_feature_value(example, feature);
    
    auto it = node->children.find(feature_value);
    if (it == node->children.end()) {
        throw std::runtime_error("Feature value '" + feature_value + "' not found in tree for feature '" + feature + "'");
    }
 
    return predict_helper(it->second.get(), example);
}






int main() {
    try {
        Dataset data = {
            {30, "High", "Single", "Class A"},
            {35, "Low", "Married", "Class B"},
            {40, "Medium", "Divorced", "Class A"},
            {25, "Low", "Single", "Class C"},
            {50, "High", "Married", "Class B"},
            {45, "Low", "Divorced", "Class A"}
        };
     
        std::vector<std::string> features = {"income", "marital_status", "age"};
     
        // 训练决策树
        std::cout << "Training decision tree..." << std::endl;
        DecisionTree dt;
        dt.fit(data, features);
        std::cout << "Training completed!" << std::endl;
     
        // 预测新样本
        Example new_example = {30, "High", "Single", ""};
        std::cout << "Predicting for example: Age=" << new_example.age 
                  << ", Income=" << new_example.income 
                  << ", Marital Status=" << new_example.marital_status << std::endl;
        
        std::string prediction = dt.predict(new_example);
        std::cout << "Prediction: " << prediction << std::endl;
        
        // 测试更多样本
        std::vector<Example> test_examples = {
            {25, "Low", "Single", ""},
            {45, "High", "Married", ""},
            {35, "Medium", "Divorced", ""}
        };
        
        std::cout << "\nTesting additional examples:" << std::endl;
        for(const auto& example : test_examples){
            std::string pred = dt.predict(example);
            std::cout << "Age=" << example.age << ", Income=" << example.income 
                      << ", Marital=" << example.marital_status << " -> " << pred << std::endl;
        }
        
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}

  

结语

        本章到这里就结束了，小H马上就要开启周末的快乐生活了，如果代码上有什么问题可以和博主联系。

决策树之ID3算法
ACdreamer
03-27 8万+
今天，我来讲解的是决策树。对于决策树来说，主要有两种算法：ID3算法和C4.5算法。C4.5算法是 对ID3算法的改进。今天主要先讲ID3算法，之后会讲C4.5算法和随机森林等。   Contents        1. 决策树的基本认识      2. ID3算法介绍      3. 信息熵与信息增益      4. ID3算法的C++实现     1. 决策树的基本认识
数据挖掘-决策树ID3分类算法的C++实现
热门推荐
Coding for Dreams
03-05 6万+
数据挖掘课上面老师介绍了下决策树ID3算法，我抽空余时间把这个算法用C++实现了一遍。决策树算法是非常常用的分类算法，是逼近离散目标函数的方法，学习得到的函数以决策树的形式表示。其基本思路是不断选取产生信息增益最大的属性来划分样例集和，构造决策树。信息增益定义为结点与其子结点的信息熵之差。信息熵是香农提出的，用于描述信息不纯度(不稳定性)，其计算公式是Pi为子集合中不同性(而二元分类即正样例和负样
C++学习笔记——标准库类型vector的使用
昭与云的博客
08-10 284
初始化 vector对象的方法v1是一个空vector，它潜在的元素是T类型的，执行默认初始化v2中包含有v1所有元素的副本等价于v2(v1)，v2中包含有v1所有元素的副本v3包含了n个重复的元素，每个元素的值都是valv4包含了n个重复地执行了值初始化的对象v5包含了初始值个数的元素，每个元素被赋予相应的初始值等价于v5{a,b,c. …}//默认初始化，s不含任何元素程序在运行时可以很高效地往vector对象中添加元素。
基于C++语言的决策树实现
Joy的博客
11-19 1万+
   感觉好久都没有写过程序了，一直上课没有时间。最近有点空，然后就写了下西瓜书中的决策树的实现。由于本人才疏学浅，采用的实现方式和数据结构可能不合理，没有考虑代码的复杂度和时间复杂度等等，仅写下自己的实现想法（大神们就打扰了）。该程序是基于C++语言来实现的，算法就是西瓜书上面的实现算法，采用最简单的ID3算法，用信息增益来选择最优划分，进而进行决策树的实现（没有对决策树进行剪枝操作，以后有时间...
基于ID3算法的决策树研究与天气预测C++实现
Matrix的博客
05-18 8904
目录 一、初识决策树 二、理论基础 三、ID3算法 四、问题实现 五、运行结果分析 六、References 一、初识决策树 决策树（ Decision Tree ）又称为判定树，是对数据进行分类的一种树结构，并通过分类达到预测的目的。决策树分为分类树和回归树两种，分类树是对离散变量做决策树，回归树是对连续变量做决策树。构造决策树是采用自上而下的递归构造方法。...
哈夫曼树
Queenie_Charlie 的博客
06-13 271
实际上，哈夫曼算法的实现与实际问题所采用的存储结构有关。现假设用数组F来存储哈夫曼树，其中第i个数组元素F[i]是哈夫曼树中的一个结点，其地址为i，有3个域，Data域存放该结点的权值，lChild域和rChild域分别存放该结点左、右子树的根结点的地址（下标）。在以后每步构造一棵新二叉树时，都需要对森林中所有二叉树的根结点进行排序，因此可用数组a作为排序暂存空间，其中第i个数组元素a[i]是森林F中第i棵二叉树的根结点，有2个域，Data是根结点所对应的权值，Addr是根结点在F中的地址（下标）。
2026年第九届GXCPC广西大学生程序设计大赛（热身赛）题解
奇妙方程式的博客
06-15 235
题目来源：未知，可在评论区补充。
百度 C++/PHP 研发一二面：一面扫八股和算法，二面开始逼近 Redis、MySQL 和秒杀设计
TechPioneer_lp的博客
06-15 175
这篇百度C++/PHP研发面经展现了后端岗位的面试进阶路径：一面侧重算法、操作系统、网络等基础（如链表判环、HTTP协议），二面则深入Redis/MySQL底层、高并发设计（如秒杀系统）。面经揭示百度筛选标准：基础合格后，重点考察缓存/数据库系统理解、高并发设计能力。建议准备时：一面夯实算法和语言基础（C++关键字/多态），二面吃透Redis/MySQL原理，并构建系统设计思维。笔试不佳仍有面试机会，但二面才是真正的能力分水岭。
《LeetCode 200 FloodFill 岛屿数量DFS解法》
2601_95366422的博客
06-15 261
LeetCode200 岛屿数量
C语言学习笔记 - 55.流程控制9 - 选择5 - if...else if多分支语句
weixin_57913829的博客
06-17 273
本文介绍了C语言中if-elseif多分支语句的核心概念和应用。该语句专门用于处理多个互斥条件的选择问题，通过自上而下依次判断表达式，从多个分支中选择且仅执行一个语句块。文章详细阐述了语法格式、执行逻辑，并提供了成绩等级划分和一元二次方程求解两个典型示例。同时指出了常见错误，如条件判断顺序错误、单独的else语句等，并对比了if-elseif与嵌套if语句的优劣，强调前者在代码简洁性和可读性方面的优势。
[LC优选算法#5] 分治:快排 | 颜色分类 | 排序数组 | 第K大元素
C++开发
06-14 345
本文介绍了基于分治思想的快速排序算法及其应用。主要内容包括：1) 分治快排与普通快排的区别，分治快排将数组分为三部分，解决了全为key值时效率退化问题；2) 通过颜色分类、排序数组和求第K大元素三个例题，详细讲解分治快排的实现和优化技巧，如随机选择基准元素；3) 特别分析了TopK问题的解法，如何在排序过程中通过区间元素数量比较快速定位目标元素。文章提供了清晰的算法图解和代码实现，展示了分治快排算法在稳定O(NlogN)时间复杂度上的优势。
芝士算法（滑动窗口片 2.0）
AKA__Zas的博客
06-13 104
因为数组只存在 ’数字串‘ 所以也可以使用数组建立哈希表 kinds 表示。题目给出了类型 要求出个数 使用。此题本质上 和 上题 没有大致区别。1）字符串 要每一小短对应 len。简单的说这一道题 从数组串要求出。的存在所以要对部分做出修改。（数组有多少个小段字符串）pluspro 加强版。
LeetCode 3264.K次乘运算后的最终数组I
tus00000的博客
06-17 214
如果nums的大小为n，数组中最大值为U，multiplier为m，则此算法时间复杂度为O(nlognlog。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。输入：nums = [1,2], k = 3, multiplier = 4。1 次操作后 [2, 2, 3, 5, 6]2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]5 次操作后 [8, 4, 6, 5, 6]
滑动窗口最大值问题：单调队列的巧妙应用
纳兰青华的博客
06-16 318
本文介绍了使用单调队列高效解决滑动窗口最大值问题的方法。通过维护一个单调递减的双端队列存储元素索引，算法能在O(n)时间复杂度内找到每个窗口的最大值。关键步骤包括：1)维护队列单调性，移除小于新元素的队尾元素；2)检查队首元素是否超出窗口范围；3)当窗口形成时记录队首最大值。相比暴力解法的O(n×w)复杂度，这种优化方案显著提升了效率，特别适合处理大规模数据。文章结合示例详细演示了算法执行过程，并分析了复杂度，最后总结了单调队列在滑动窗口问题中的通用性。
算法总结（链表、哈希）
最新发布
2503_93247646的博客
06-17 600
在文章的最后，还有一个细节需要被提及，就是虚拟头节点。无论是我们构建链表，还是做链表的算法题也好，虚拟头节点一直是我们无法回避的一个点，不是说没有虚拟头节点我们做不了，而是可以更加的方便，可以把所有的操作全部统一而且不需要考虑空链表报错的情况本篇文章就到这里结束了，希望可以对大家有所帮助~~~
需求预测终极指南：零售商品预测方法、算法与AI实践
06-16 386
需求预测（Demand Forecasting）是零售企业利用历史销售数据、市场趋势、促销计划、季节性规律和外部环境因素，通过统计模型或机器学习算法，对未来特定时间段内各SKU销售量进行系统性预测的过程。区分需求预测与相关概念：需求预测关注数量维度（预测卖多少件），销售预测关注金额维度（预测卖多少钱），两者相乘得到销售金额预测，共同构成商品预算的数据基础。需求预测不等于销售目标——目标是战略性设定，预测是数据驱动的量化估算，两者可以不同，不应强制对齐。
算法札记：归并排序
Keven_11的博客
06-16 187
摘要：本文对比了归并排序与快速排序的特性。归并排序稳定，时间复杂度稳定为O(nlogn)，但需要额外空间；快速排序不稳定，平均复杂度O(nlogn)，最坏O(n²)，但空间效率高且缓存友好。实际应用中，快排因优化技术（如三数取中）更常用，而归并排序在需要稳定性、外部排序和链表排序等场景不可替代。现代语言常采用混合策略兼顾二者优点。理解两种算法的适用场景对实际编程选型至关重要。（149字）
BP神经网络用什么训练算法(traingd、traingdm、trainlm)
dbat
06-14 207
在使用matlab来训练BP神经网络时，我们不免会疑惑，究竟要怎么选择训练函数呢？
算法札记：模拟栈、模拟队列
Keven_11的博客
06-17 238
在算法竞赛中，数组模拟数据结构往往比STL容器更具优势。数组模拟栈（用tt指针）和队列（用hh/tt指针）能显著提升性能，避免TLE，且支持清空、遍历等灵活操作。其核心代码简洁（约5行），在NOIP等竞赛中已成惯例。而priority_queue等复杂结构仍建议使用STL。选择依据：大数据量/关键比赛用手写，小数据量/O2优化环境下可用STL。这种优化策略源自竞赛圈实践，由"豆包"等大神总结推广。（149字）
气象预警Agent等级判定算法：2026年AI驱动的概率集合预报与自动化闭环实践
企业级智能体，全行业解决方案，5000+企业签约，海量场景覆盖。
06-12 97
摘要： 2026年，AI Agent驱动的智慧气象系统实现全球落地，气象预警算法完成从确定性预报向概率集合判定的范式升级。新一代算法通过集合预报和动态阈值修正，实现极端天气长尾风险识别与秒级响应。以深圳“阿福”和实在Agent为代表的智能体，深度融合大模型与超自动化技术，支持跨系统操作和全链路闭环决策，推动企业从信息化迈向智能化。新算法还耦合跨部门数据，形成“一设施一预警”的精细化能力，但需注意算力依赖与人工终审等边界条件。AI Agent正成为社会运行的核心中枢，重构人机协同范式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱吃芒果的蘑菇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值