web-dev-qa-db-ja.com

std :: multimapの一意のキーにイテレータはありますか？

マルチマップの一意のキーを反復処理するマルチマップイテレータを使用する簡単な方法または標準的な方法はありますか？

つまり、次のようなセットの場合：{1, "a"}, {1, "lemon"}, {2, "peacock"}, {3, "angel"}{1, "a"}で始まるイテレータで、インクリメントすると{2, "peacock"}をポイントし、再度インクリメントすると{3, "angel"}？をポイントします。

c++multimap
40
Bingo

upper_boundの代わりに++を使用して、イテレータの位置を増やすことができます。

#include <map>
#include <string>
#include <iostream>

using namespace std;

int main()
{
  multimap<int,string> mm;
  mm.insert(make_pair(1, "a"));
  mm.insert(make_pair(1, "lemon"));
  mm.insert(make_pair(2, "peacock"));
  mm.insert(make_pair(3, "angel"));

  for( auto it = mm.begin(), end = mm.end();
       it != end;
       it = mm.upper_bound(it->first)
  )
    cout << it->first << ' ' << it->second << endl;
  return 0;
}

これ 結果 ：

1 a
2 peacock
3 angel
46
Pablo

upper_boundを使用するとループが読みやすくなりますが、各呼び出しはバイナリツリー検索を実行し、O（n log n）O（n）トラバーサルの代わりに。効率の違いが問題になる場合は、次のようにトラバーサルを構成できます。

typedef std::multimap<std::string, int> MapType;
MapType container;
for (MapType::iterator it = container.begin(); it != container.end(); ) {
  std::string key = it->first;

  doSomething(key);

  // Advance to next non-duplicate entry.
  do {
    ++it;
  } while (it != container.end() && key == it->first);
}
27
user3701170

選択した回答に記載されているように、multimap::upper_boundを繰り返し使用すると、マップのO（n log n）トラバーサルが発生します。外部upper_bound関数を使用すると、O（n）が得られます。ただし、マップのキーのみを比較することを確認する必要があります。

std::multimap<int, std::string> myMap = ... ;
const auto compareFirst = [](const std::pair<const int, std::string>& lhs, const std::pair<const int, std::string>& rhs) {
    return lhs.first < rhs.first;
};

for(auto it = myMap.begin(); it != myMap.end(); it = std::upper_bound(it, myMap.end(), *it, compareFirst)) {
    // Do stuff...

}

基本的なアプローチは基本的にuser3701170のソリューション（つまり線形検索）と同じですが、ループの本体ではなく、forステートメントに増分ステップを入れます。 「通常」存続する場所にインクリメントを配置する以外に、これは、ループ内のcontinueステートメントが期待どおりに動作することも意味します。

4
Stewart Becker

実行可能な例

これは、実行可能な単体テストでの https://stackoverflow.com/a/24212648/895245 よりもわずかに改善されています。

#include <cassert>
#include <map>
#include <vector>

int main() {

    // For testing.
    auto m = std::multimap<int, int>{
        {1, 2},
        {1, 3},
        {2, 4}
    };
    std::vector<int> out;

    // The algorithm.
    auto it = m.begin();
    auto end = m.end();
    while (it != end) {
        auto key = it->first;

        // Do what you want to do with the keys.
        out.Push_back(key);

        do {
            if (++it == end)
                break;
        } while (it->first == key);
    }

    // Assert it worked.
    assert(out == std::vector<int>({1, 2}));
}
2
Ciro Santilli 冠状病毒审查六四事件法轮功

すべての一意のキーをすばやく渡す必要がある場合は、代わりにstd :: mapを使用できます。

typedef std::map< KeyType, std::list< ValueType > > MapKeyToMultiValue;

挿入はより困難ですが、重複するエントリを気にすることなく、すべてのキーを反復処理できます。挿入は次のようになります。

void insert_m(MapKeyToMultiValue &map, const KeyType key, const ValueType value )
{
  auto it = map.find( key );
  if (it == map.end())
  {
     std::list<ValueType> empty;
     std::pair< MapKeyToMultiValue::iterator, bool > ret =
        map.insert( MapKeyToMultiValue::value_type( key, empty ) );
     it = ret.first;
  }

  it->second.Push_back( value );
}

または、非常にテンプレート化することもできます。

template<typename KeyType, typename ValueType, 
     typename MapType = std::map< KeyType, std::list< ValueType > > >
void insert_multi( MapType &map, const KeyType key, const ValueType value )
{

  auto it = map.find( key );
  if (it == map.end())
  {
     std::list<ValueType> empty;
     std::pair< typename MapType::iterator, bool > ret =
        map.insert( typename MapType::value_type( key, empty ) );
     it = ret.first;
  }

  it->second.Push_back( value );
}

完全なテストプログラムは次のようになります。

#include <map>
#include <list>
#include <string>
#include <stdio.h>

typedef std::string KeyType;  
typedef int ValueType;

typedef std::map< KeyType, std::list< ValueType > >  MapKeyToMultiValue;

void insert_m(MapKeyToMultiValue &map, const KeyType key, const ValueType value )
{
  auto it = map.find( key );
  if (it == map.end())
  {
     std::list<ValueType> empty;
     std::pair< MapKeyToMultiValue::iterator, bool > ret =
        map.insert( MapKeyToMultiValue::value_type( key, empty ) );
     it = ret.first;
  }

  it->second.Push_back( value );
}


template<typename KeyType, typename ValueType, 
   typename MapType = std::map< KeyType, std::list< ValueType > > >
void insert_multi( MapType &map, const KeyType key, const ValueType value )
{

  auto it = map.find( key );
  if (it == map.end())
  {
     std::list<ValueType> empty;
     std::pair< typename MapType::iterator, bool > ret =
        map.insert( typename MapType::value_type( key, empty ) );
     it = ret.first;
  }

  it->second.Push_back( value );
}


int main()
{
    MapKeyToMultiValue map;


    insert_m(map, std::string("aaa"), 1 );
    insert_m(map, std::string("aaa"), 2 );
    insert_m(map, std::string("bb"), 3 );
    insert_m(map, std::string("cc"), 4 );


    insert_multi(map, std::string("ddd"), 1 );
    insert_multi(map, std::string("ddd"), 2 );
    insert_multi(map, std::string("ee"), 3 );
    insert_multi(map, std::string("ff"), 4 );


    for(auto i = map.begin(); i != map.end(); ++i)
    {
      printf("%s\n", i->first.c_str() );
    }


    return 0;
}
1
MichaelMoser

equal_rangeをお試しください：

http://en.cppreference.com/w/cpp/container/multimap/equal_range

それは完全に一致する必要があります。

0
Red.Wave