在 std::map 中查找最接近或准确的键

Question

我需要创建一个将长度链接到时间间隔的查找表（两者都是双精度数据类型）。键在插入时线性递增，因此它已经被排序（也许 unordered_map 会更好？）。

我正在寻找一种方法来找到与提供的当前长度最匹配的密钥以获取时间值，或者更好地找到围绕长度的两个密钥（给定密钥在它们之间），这样我就可以找到两个时间值之间的插值。

我还需要尽可能好的性能，因为它会被实时调用。

编辑：我宁愿以下是对下面第一个答案的评论，但格式很难阅读。

我尝试执行以下操作，但它似乎返回相同的迭代器 (5.6)：

std::map<double, double> map;
map.insert(std::pair<double, double>(0.123, 0.1));
map.insert(std::pair<double, double>(2.5, 0.4));
map.insert(std::pair<double, double>(5.6, 0.8));

std::map<double, double>::iterator low, high;
double pos = 3.0;
low = map.lower_bound(pos);
high = map.upper_bound(pos);

我如何获得“低”以指向最后一个元素

编辑 2： 愚蠢的我，'低-'会做到这一点，前提是它不是第一个元素。

到达那里:)

Answer 1

为此，您可以使用std::map::lower_bound

返回一个迭代器，指向不小于key的第一个元素。

或std::map::equal_range

返回一个范围，其中包含容器中具有给定键的所有元素。

---

在您的情况下，如果您想要最接近的条目，则需要检查返回的条目和之前的条目并比较差异。这样的事情可能会起作用

std::map<double, double>::iterator low, prev;
double pos = 3.0;
low = map.lower_bound(pos);
if (low == map.end()) {
    // nothing found, maybe use rbegin()
} else if (low == map.begin()) {
    std::cout << "low=" << low->first << '\n';
} else {
    prev = std::prev(low);
    if ((pos - prev->first) < (low->first - pos))
        std::cout << "prev=" << prev->first << '\n';
    else
        std::cout << "low=" << low->first << '\n';
}

Answer 2

“可能的最佳性能” - 假设你以递增的顺序插入元素，你可以 push_back/emplace_back 将它们放入 std::vector 然后使用 std::lower_bound - 你会变得更好缓存利用率，因为数据将被打包到连续的地址空间中。

Answer 3

您当然可以使用 lower_bound 和 upper_bound，它们在运行时是对数的。他们应该做你想做的。

std::map<double,double>::iterator close_low;
//... your_map ...
close_low=your_map.lower_bound (current_length);

这应该给你一个迭代器，指向第一个键为

Answer 4

std::lower_bound() 和 std::upper_bound() 函数在这里很有用。

lower_bound() 将>= 的第一个元素赋予您要查找的值； upper_bound() 给出的第一个元素是>，而不是值。

例如，在以下列表中搜索值 5：{1,3,5,5,6}¹ 使用 lower_bound() 返回第三个元素，而 upper_bound() 将返回第五个元素。 如果这两个函数返回相同的东西x，那么您要查找的值不在列表中。 它前面的值是x-1，后面的值是x。

¹_{正如Tony D 在评论中指出的那样，该问题要求地图，一般不包含重复元素。 我保留这个例子来说明这两个功能。}

Answer 5

完整的通用解决方案（最初的想法取自Olaf Dietsche的answer）：

#include <map>
#include <iostream>
#include <cstdint>

template <typename T1, typename T2>
T1 findClosestKey(const std::map<T1, T2> & data, T1 key)
{
    if (data.size() == 0) {
        throw std::out_of_range("Received empty map.");
    }

    auto lower = data.lower_bound(key);

    if (lower == data.end()) // If none found, return the last one.
        return std::prev(lower)->first;

    if (lower == data.begin())
        return lower->first;

    // Check which one is closest.
    auto previous = std::prev(lower);
    if ((key - previous->first) < (lower->first - key))
        return previous->first;

    return lower->first;
}

int main () {
double key = 3.3;

std::map<double, int> data = {{-10, 1000}, {0, 2000}, {10, 3000}};

std::cout << "Provided key: " << key << ", closest key: " << findClosestKey(data, key) << std::endl;
return 0;
}

Answer 6

#include <map>

template <typename T1, typename T2>
std::map<T1, T2>::iterator nearest_key(const std::map<T1, T2>& map, T1 key) {
    auto lower_bound = map.lower_bound(key);
    auto upper_bound = lower_bound; upper_bound++;
    if (lower_bound == map.end()) return upper_bound;
    if (upper_bound == map.end()) return lower_bound;
    unsigned int dist_to_lower = std::abs((int)lower_bound->first - (int)key);
    unsigned int dist_to_upper = std::abs((int)upper_bound->first - (int)key);
    return (dist_to_upper < dist_to_lower) ? upper_bound : lower_bound;
}

Answer 7

以上是错误的。应该是这样的 模板

typename std::map<T1, T2>::const_iterator nearest_key(const std::map<T1, T2>& map, T1 key)
{
    auto lower_bound = map.lower_bound(key);
    if (lower_bound == map.end()) return --lower_bound;
    auto upper_bound = lower_bound; upper_bound++;
    if (upper_bound == map.end()) return lower_bound;
    auto dist_to_lower = lower_bound->first - key;
    auto dist_to_upper = upper_bound->first - key;
    return (dist_to_upper < dist_to_lower) ? upper_bound : lower_bound;
}