c++ - 我将如何优化这段代码？

Question

我正在编写一个函数来查找一个数组的平均值，其中该数组主要是如果一次添加所有数字就会溢出的数字。

它的工作原理是创建一个子数组(b 在我的代码中)，它是输入(a 在我的代码中)数组大小的一半(ar_size 在我的代码中)然后将输入数组 a[i+0] 和 a[i+1] 的 2 个值的平均值放入 b[j]。

一旦遍历整个输入数组，它会重新运行函数并返回子数组和输入数组大小，直到大小等于 2，然后通过返回 b[2] 的两个值的平均值结束递归]。

请原谅重用j。

数组的大小也是 2 的幂。

uint64_t* array_average(uint64_t* a, const int ar_size)
{
    uint64_t* b = new uint64_t[ar_size / 2];

    uint64_t* j = new uint64_t;

    if (ar_size == 2)
    {
     *j = (a[0] / 2) + (a[1] / 2) + ((a[0] % 2 + a[1] % 2) / 2);

     return j;
    }

    for (int i = 0; i < ar_size; i += 2)
    {
        b[*j] = (a[i + 0] / 2) + (a[i + 1] / 2) + ((a[i + 0] % 2 + a[i + 1] % 2) / 2);

        ++*j;
    }
    delete j;
    return array_average(b, ar_size / 2);
}

在处理会导致溢出发生的数字时，还有人有更好的平均方法吗？

修改后的版本:

uint64_t* tools::array_average(uint64_t* a, const int ar_size)
{
    uint64_t* b = new uint64_t[ar_size];
    uint64_t* c = new uint64_t[ar_size / 2];

    int j;
    j = 0;

    for (int i = 0; i < ar_size; ++i)
    {
        b[i] = a[i];
    }

    if (runs > 0) //This is so i do not delete the original input array I.E not done with it
    {
        delete[] a;
    }

    if (ar_size == 2)
    {
        uint64_t* y = new uint64_t;

        runs = 0;

        *y = (b[0] / 2) + (b[1] / 2) + ((b[0] % 2 + b[1] % 2) / 2); 

        delete[] b;

        return y;
    }

    for (int i = 0; i < ar_size; i += 2)
    {
        c[j] = (b[i + 0] / 2) + (b[i + 1] / 2) + ((b[i + 0] % 2 + b[i + 1] % 2) / 2);

        ++j;
    }

    delete[] b;

    ++runs;

    return array_average(c, ar_size / 2);

Answer 1

首先，请注意您的平均值不是实际平均值，因为您确实扔掉了一半。你的算法在 0 和 1 之间交替的数组上的结果将是 0，因为 0/2 + 1/2 + (0%2 + 1%2)/2 = 0。想从那个开始，因为那是你算法的一个严重弱点。

另请注意，如果原始大小不是2的幂，则某些数据会获得更高的权重。

除此之外，请考虑以下算法:复制数据。直到数据只剩下一个条目，将单元格 0 和 1 的平均值放入单元格 0，将 2 和 3 的平均值放入单元格 1，将 4 和 5 的平均值放入 2，依此类推。在每个这样的步骤之后收缩数据。

作为代码:

uint64_t average(std::vector<uint64_t> data)
{
    while(data.size() != 1)
    {
        for(size_t i=0; i<data.size()/2; i++)
        {
            data[i] = data[2*i]/2 + data[2*i+1]/2 + /* modular stuff */;
        }
        data.resize(data.size()/2 + data.size()%2); //last part is required if the size is not an even number
    }
    return data[0];
}

顺便说一下，在这里使用合适的容器也可以避免内存泄漏。

请注意，这段代码仍然存在我所说的弱点。您可以通过收集一半来扩展它，也就是说，如果您的模块化部分是 1，则增加一个变量，当变量为二时，您在某个单元格中添加一个。

编辑:如果输入必须是原始数组(例如，因为您从某个外部源接收到它)，请使用:

uint64_t average(uint64_t* array, const int array_size)
{
    std::vector<uint64_t> data(array, array + array_size);

    (rest of the code is identical)

编辑:上面的代码与收集的一半:

inline uint64_t average(const uint64_t& a, const uint64_t& b, uint8_t& left_halves)
{
    uint64_t value = a/2 + b/2 + (a%2 + b%2)/2;
    if((a%2 + b%2)%2 == 1)
    {
        left_halves += 1;
    }
    if(left_halves == 2)
    {
        value += 1;
        left_halves = 0;
    }
    return value;
}

uint64_t average(std::vector<uint64_t> data)
{
    if(data.size() == 0) return 0;

    uint8_t left_halves = 0;
    while(data.size() != 1)
    {
        for(size_t i=0; i<data.size()/2; i++)
        {
            data[i] = average(data[2*i], data[2*i+1], left_halves);
        }
        data.resize(data.size()/2 + data.size()%2); //last part is required if the size is not an even number
    }
    return data[0];
}

如果大小不是 2 的幂，仍然存在细胞重量增加的弱点。