在向量的向量中找到最大位置

我建议线性化您的数据，以便能够使用标准算法。这个想法是提供几个函数来从 3D 坐标获取索引，反之亦然：

template<class T>
class Matrix3D // minimal
{
public:
    using value_type = T;
    using iterator   = std::vector<value_type>::iterator;
private:
    std::vector<value_type> _data;
    size_t _sizex, _sizey, _sizez;
    size_t index_from_coords(size_t x, size_t y, size_t z) const
    {
        return x*_sizex*_sizey + y*_sizey + z;
    }
    std::tuple<size_t, size_t, size_t> coords_from_index(size_t index) const
    {
        const size_t x = index / (_sizex * _sizey);
        index = index % x;
        const size_t y = index / _sizey;
        const size_t z = index % _sizey;
        return make_tuple(x, y, z);
    }
public:
    Matrix3D(size_t sizex, sizey, sizez) : _sizex(sizex), ... {}
    T& operator()(size_t x, size_t y, size_t z) // add const version
    {
        return _data[index_from_coords(x, y, z)];
    }
    std::tuple<size_t, size_t, size_t> coords(iterator it)
    {
        size_t index = std::distance(begin(_data), it);
        return coords_from_index(index);
    }
    iterator begin() { return begin(_data); }
    iterator end()   { return end(_data);   }
}

用法：

Matrix3D<double> m(3, 3, 3);
auto it = std::max_element(m.begin(), m.end()); // or min, or whatever from http://en.cppreference.com/w/cpp/header/algorithm
auto coords = m.coords(it);
std::cout << "x=" << coords.get<0>() << ... << "n";

这是未经测试和不完整的代码，可以为您提供更好的数据设计的入门。 我很乐意在下面的评论中回答有关这个想法的进一步问题;)

以下是我的做法，通过遍历矩阵、检查最大值并记录其索引。

size_t highestI = 0;
size_t highestJ = 0;
size_t highestK = 0;
double highestValue = -std::numeric_limits<double>::infinity(); // Default value (Include <limits>)
for (size_t i = 0; i < mountain_table.size(); ++i)
{
    for (size_t j = 0; j < mountain_table[i].size(); ++j)
    {
        for (size_t k = 0; k < mountain_table[i][j].size(); ++k)
        {
            if (mountain_table[i][j][k] > highestValue)
            {
                highestValue = mountain_table[i][j][k]; // Highest 
                // value needed to figure out highest indexes
                // Stores the current highest indexes
                highestI = i; 
                highestJ = j;
                highestK = k;
            }
        }
    }
}

这可能不是最有效的算法，但它以可理解的方式完成工作。

由于 max_element 函数非常短且易于实现，因此我建议您自己编写类似的东西以适合您的确切场景。

// For types like this I would suggest using a type alias
using Vector3d = std::vector<std::vector<std::vector<double>>>;
std::array<size_t, 3> max_element(const Vector3d& vector) {
    std::std::array<size_t, 3> indexes;
    double biggest = vector[0][0][0];
    for (unsigned i = 0; i < vector.size(); ++i)
        for (unsigned j = 0; j < vector[i].size(); ++j)
            for (unsigned k = 0; k < vector[i][j].size(); ++k)
                if (value > biggest) {
                    biggest =  value;
                    indexes = { i, j, k };
                }
    return indexes;
}

我可以给你的另一个建议是编写你的自定义类Vector3d，使用operator()(int x, int y, int z)等方便的功能，并在内部以大小width * height * depth的简单vector<double>保存数据。

std::size_t rv[3] = {0};
std::size_t i = 0;
double max_value = mountain_table[0][0][0];
for (const auto& x : mountain_table) {
  std::size_t j = 0;
  for (const auto& y : x) {
    auto it = std::max_element(y.begin(), y.end());
    if (*it > max_value) {
      rv[0] = i; rv[1] = j; rv[2] = it - y.begin();
      max_value = *it;
    }
    ++j;
  }
  ++i;
}

我认为你不能对这些数据使用std::max_element。您可以使用std::accumulate()：

using dvect = std::vector<double>;
using ddvect = std::vector<dvect>;
using dddvect = std::vector<ddvect>;
dddvect mx = { { { 1, 2, 3 }, { -1, 3 }, { 8,-2, 3 } },
               { {}, { -1, 25, 3 }, { 7, 3, 3 } },
               { { -1, -2, -3 }, {}, { 33 } } };
struct max_value {
    size_t i = 0;
    size_t j = 0;
    size_t k = 0;
    double value = -std::numeric_limits<double>::infinity();
    max_value() = default;
    max_value( size_t i, size_t j, size_t k, double v ) : i( i ), j( j ), k( k ), value( v ) {}
    max_value operator<<( const max_value &v ) const
    {
        return value > v.value ? *this : v;
    }
};
auto max = std::accumulate( mx.begin(), mx.end(), max_value{}, [&mx]( const max_value &val, const ddvect &ddv ) {
    auto i = std::distance( &*mx.cbegin(), &ddv );
    return std::accumulate( ddv.begin(), ddv.end(), val, [i,&ddv]( const max_value &val, const dvect &dv ) {
        auto j = std::distance( &*ddv.cbegin(), &dv );
        return std::accumulate( dv.begin(), dv.end(), val, [i,j,&dv]( const max_value &val, const double &d ) {
            auto k = std::distance( &*dv.cbegin(), &d );
            return val << max_value( i, j, k, d );
        } );
    } );
} );

活生生的例子。如果允许 C++14 或更高版本，代码可以简化，但我不确定它会更糟，工作量和数据重组很可能会更好地工作(例如，您可以在单个向量上使用 std::max_element()(。另一方面，此布局支持如示例所示的锯齿矩阵(不同大小的子数组(

你应该使用"for"循环，因为你没有3d向量。

for (size_t i = 0; i <mountain_table.size(); ++i)
{
  for (size_t j = 0; j < mountain_table[i].size() ++j)
    {
     // find max element index k here and check if it is maximum.
     // If yes save i, j, k and update max val
    }
}