问在C++中，如何使用最大差值阈值来寻找聚类平均值

EN

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    std::vector<float> samples = {1.f,2.f,3.f,30.f,31.f,32.f};
    std::vector<float> clustersAvg; // the averages per cluster
    float clusterAcc =0.f; // current cluster accumulated values
    int clusterSize = 0; // current cluster size
    float lastSample = samples[0];
    for (const auto&sample:samples)
    {
        if (abs(sample - lastSample) <= 25) // check if threshold is reached or not
        {
            clusterAcc += sample;
            clusterSize ++;

        }
        else
        {
            // threshold reached, let's average what we accumulated so far
            clustersAvg.push_back(clusterAcc/clusterSize);
            clusterAcc = sample;
            clusterSize = 1;
        }
        lastSample = sample; // keep track of sample for next threshold checking
    }

    clustersAvg.push_back(clusterAcc/clusterSize); // last accumulation

    // print results
    for (const auto & avg:clustersAvg)
    {
        cout << "avg: " << avg << endl;
    }
}

#include <iostream>
#include <vector>

int main() {
    // Test Data. Here in a vector, can be any other container
    std::vector sample{
        1,2,1,3,2,1,3,4,2,3,5,2,3,
        30,29,32,28,33,32,34,31,35,34,31,
        82,81,83,86,84,86,87,85,86,82,
        111,112,113,112,114,115,113,112,113 };

    // Some threshold example
    constexpr int threshold{ 20 };

    // Here we count the elements in one group of somehow similare sample values
    int groupCounter{};
    // And this is the sum of one group of somehow similar sample values
    double groupSum{};

    // Check all sample data
    for (size_t i{}; i < sample.size(); ++i) {

        // Accumulate the data
        groupSum += sample[i];
        ++groupCounter;

        // If we have a "jump" or are at the last value
        if ((i == sample.size() - 1) || (std::abs(sample[i + 1] - sample[i]) > threshold)) {

            // Prevent division by 0
            if (groupCounter > 0) {
                // Show resulting avaerage of this group
                std::cout << "Average value:\t" << groupSum / groupCounter << '\n';
            }
            else {
                std::cerr << "\nError: No further data\n";
            }
            // Reset values to do calculations for the next run
            groupCounter = 0;
            groupSum = 0.0;
        }
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <iterator>

// Abbreviations for easier writing
using Container = std::vector<double>;
using Iter = Container::iterator;

int main() {

    // The test data
    Container sample{ 1,2,1,3,2,1,3, 30,29,32,28,33,32, 82,81,83,86,84,86, 112,114,115,113,112,113};

    // Some threshold
    constexpr double threshold = 20.0;

    // Simple For loop. Go over container from start to end
    for (Iter result{}, start = {sample.begin()}; start != sample.end(); start = result)
    {
            // Search the "jump" in data
            result = std::adjacent_find(start, sample.end(),
                [threshold](const double& d1, const double& d2) { return std::abs(d1 - d2) > threshold; });

            // Set result to the next element after the found value
            result = (result != sample.end()) ? std::next(result) : sample.end();

            // Show result of calculation to user
            std::cout << std::accumulate(start, result, 0.0) / std::distance(start, result) << '\n';
    }
    return 0;
}