标签: stdset

我需要检查std::set一个范围中是否包含元素/元素.例如,如果集合是a set<int> {1, 2, 4, 7, 8},并给定一个int间隔[3, 5](包括两个端点),我需要知道它是否在集合中有元素.在这种情况下,返回true.但是如果间隔是[5, 6],则返回false.间隔可以是[4, 4],但不是[5, 3].

看起来我可以使用set::lower_bound,但我不确定这是否是正确的方法.我还希望尽可能降低复杂性.我相信使用lower_bound是对数,对吗？

所以我有一套 pairs<string ,string>

我想用来find()搜索一对字符串,这个字符串位于该对的"第一个"中,然后如果我首先找到该字符串,我想从该函数返回第二个字符串.

我目前的尝试是......

myList::iterator i;

i = theList.find(make_pair(realName, "*"));

return i->second;

是否可以使用STL算法将std :: map值深度复制到std :: set？

我不想在新集中明确插入.

我不希望明确这样做:

std::map<int, double*> myMap; //filled with something
std::set<double*> mySet;

for (std::map<int, double*>::iterator iter = myMap.begin(); iter!=myMap.end(); ++iter)
{
     mySet.insert(iter->second);
}

但是要找到一种更加巧妙和优雅的方式来做到这一点,并带有深刻的价值观.

简单地说,如果我有一个集合和向量,我如何创建一个可以同时处理params的泛型方法.

我想要做的就是迭代任何类型的集合.听起来应该是微不足道的,但我错过了一些东西.

void printMeSomeStrings(somebaseclass<string> strings) {
  for (auto& str : strings) {
    cout << str << endl;
  }
}

在C#中,我会传递IEnumerable或类似的东西.然后我可以迭代收集.

任何解释答案的一般性阅读将不胜感激.

我试图弄清楚从std :: set中删除多个元素的复杂性.我正在使用此页面作为来源.

它声称使用迭代器擦除单个项目的复杂性是分摊O(1),但使用范围形式擦除多个项目是log(c.size())+ std :: distance(first,last)(即 - 集合大小的日志+删除的元素数量).

从面值来看,如果要擦除的元素的数量(n)远小于集合(m)中的元素的数量,则这意味着在要擦除的元素上循环并且一次擦除它们的速度更快(O(n))比用一次调用擦除它们(假设n << m)为O(log m).

显然,如果真的如此,第二种形式的内部实现只会做上述循环.

这是网站上的错误吗？规格中的错误？我只是错过了一些东西吗？

谢谢,Shachar

我有以下代码行：

const char *values[] = { "I", "We", "You", "We"};
std::set<const char*> setValues;

for( int i = 0; i < 3; i++ ) {

    const char *val = values[i];
    std::set<const char*>::iterator it = setValues.find( val );

    if( it == setValues.end() ) {
        setValues.insert( val );
    }
    else {
        cout << "Existing value" << endl;
    }
}

有了这个，我试图在 a 中插入非重复值set，但不知何故代码没有点击打印现有元素并且重复值被插入。

这里有什么问题？

我一直在学习c ++.我遇到了这个问题.

我设置了包含一个自定义结构,其中包含两个long int的a&b.我有一个比较数字的自定义比较器结构,如果a或b不同,则返回true.

typedef long int li;

struct number {
    number(li a1,li b1): a(a1), b(b1) {}
    li a, b;
};

struct compare {
    bool operator() (const number &lhs, const number& rhs) const{
        return lhs.a != rhs.a || lhs.b != rhs.b;
    }
};

int main() {
    set<number, compare> nums;
    nums.insert(number(1, 2));
    nums.insert(number(1, 1));
    nums.insert(number(2, 1));
    nums.insert(number(1, 2));
    for (auto &i : nums) {
        cout << i.a << " " << i.b << endl;
    }
    return 0; …

假设我有一个std::set(根据定义排序),并且我有另一系列的排序元素(为了简单起见,在另一个std::set对象中).此外,我保证第二组中的所有值都大于第一组中的所有值.

我知道我可以有效地插入一个元素std::set- 如果我传递一个正确的hint,这将是O(1).我知道我可以插入任何范围std::set,但是当没有hint通过时,这将是O(k logN)(其中k是新元素的数量,N个旧元素的数量).

我可以在a中插入一个范围std::set并提供一个hint？我能想到的唯一方法是使用a进行单个插入hint,这确实将我的情况下插入操作的复杂性降低到O(k):

std::set <int> bigSet{1,2,5,7,10,15,18};
std::set <int> biggerSet{50,60,70};  

for(auto bigElem : biggerSet)
    bigSet.insert(bigSet.end(), bigElem);

我正在使用 C++17。

std::set是一个模板类型：

template<
    class Key,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<Key>
> class set;

可以将 astd::set作为数据成员。例如：

#include <set>

class Foo
{
    std::set<size_t> someSet_;
};

还可以明确指定比较函数。例如：

#include <set>

auto compare = [](size_t index1, size_t index2) {
    return index1 < index2;
};

class Foo
{
public:
    Foo() : someSet_(compare)
    {
    }

private:
    std::set<size_t, decltype(compare)> someSet_;
};

现在，假设比较函数是成员函数。例如：

#include <set>
#include <vector>

class Foo
{
public:
    Foo() : someSet_(compare) // does not compile
    {
    }

private:
    bool …

之间有什么区别集key_comp :: VS集:: value_comp在C ++？转到 cplusplus.com 页面没有显着差异。此外，在 set::key_comp 和相关 set::value_comp 页面上的最后一句是“(...) key_comp 及其兄弟成员函数 value_comp 是等效的。”

示例几乎相同：

http://www.cplusplus.com/reference/set/set/key_comp/

http://www.cplusplus.com/reference/set/set/value_comp/