wenn ich 2 maps vom selben Typ habe und aus der einen Map alle Einträge die einen Key haben, der auch in der anderen map enthalten ist, wie geht das dann am besten?
Gibts da vll irgendnen algorithmus, den man verwenden kann oder so?

Mein naiver Ansatz wäre:

#include <map>
#include <string>
using namespace std;

void foo()
{
   typedef map<int, string> MyMap;
   MyMap m1,m2;
   fillWithValues(m1);
   fillWithOtherValues(m2);
   for(MyMap::iterator i = m1.begin(); i!= m1.end(); ++i)
   {
      m2.erase(i->first);
   }
}

Geht das vll noch kürzer/besser?

auto i = m1.begin();
auto j = m2.begin();
while(i != m1.end() && j != m2.end())
{
    if(i->first == j->first)
    {
        m2.erase(j++);
        ++i;
    }
    else
        ++j;
}

Es kommt auf die Größenverhältnisse zwischen den beiden Maps an, welche Komplexität als besser zu betrachten ist.

Deine jetzige Implementierung hat Komplexität O(n* log n). Es geht auch in linearer Zeit, wenn du die Sortierung berücksichtigst. Das geht in etwa so:

auto i = m1.begin();
auto j = m2.begin();
while(i != m1.end() && j != m2.end())
{
    if(i->first == j->first)
    {
        m2.erase(j++);
        ++i;
    }
    else
        ++j;
}

Ohne es groß durchzuprobieren, ahbe ich meine Zweifel, dass ein == reicht, um zu entscheiden, ob es ++i oder ++j sein muss.

Ich muss aber zugeben, dass ich ohne nachzuschaun nicht genau weiß, wie die funktionieren.
Aber für map wird das vermutlich nicht funktionieren.

Zu dem keyword

auto

: Das funktioniert aber nur mit C++0x, oder?
Ich benutz MSVC 2010 und hab bisher noch nichts mit 0x versucht, aber eigentlich siehts ganz praktisch aus.

#include <algorithm>
#include <iostream>
#include <iterator>
#include <map>
#include <string>

struct pair_key_compare {
  template<typename T, typename U>
  bool operator()(std::pair<T, U> const &lhs,
                  std::pair<T, U> const &rhs) {
    return lhs.first < rhs.first;
  }
};

int main() {
  std::map<int, std::string> m1, m2, m3;

  m1[1] = "foo";
  m1[2] = "bar";
  m1[3] = "baz";

  m2[1] = "qux";
  m2[3] = "quux";
  m2[5] = "xyzzy";

  std::set_difference(m2.begin(), m2.end(),
                      m1.begin(), m1.end(),
                      std::inserter(m3, m3.begin()),
                      pair_key_compare());

  for(std::map<int, std::string>::const_iterator i = m3.begin(); i != m3.end(); ++i) {
    std::cout << i->first << " -> " << i->second << '\n';
  }
}

Was den Algorithmus angeht, da reicht == in der Tat nicht, zumal der Schlüssel einer Map diesen Operator gar nicht zwingend braucht. So sollte es gehen:

auto i = m1.begin();
auto j = m2.begin();

while(i != m1.end() && j != m2.end()) {
  if(i->first < j->first) {
    ++i;
  } else if(j->first < i->first) {
    ++j;
  } else {
    m2.erase(j++);
    ++i;
  }
}

Ohne es groß durchzuprobieren, ahbe ich meine Zweifel, dass ein == reicht, um zu entscheiden, ob es ++i oder ++j sein muss.

Wie meinst du das? Edit: Jetzt seh ichs auch.

BTW: Man kann die Performance noch steigern, indem man zwei verschachtelte Schleifen macht, sodass nciht nach jedem Inkrementieren von j geprüft werden muss, ob i == m1.end() ist.

Deine jetzige Implementierung hat Komplexität O(m * log n), wobei m die Größe von m1 und n die Größe von m2 ist. Es geht auch in linearer Zeit O(m + n), wenn du die Sortierung berücksichtigst. Das geht in etwa so:

auto i = m1.begin();
auto j = m2.begin();
while(i != m1.end() && j != m2.end())
{
    if(i->first == j->first)
    {
        m2.erase(j++);
        ++i;
    }
    else
        ++j;
}

Es kommt auf die Größenverhältnisse zwischen den beiden Maps an, welche Komplexität als besser zu betrachten ist.

Du geht davon aus, daß erase() O(1) ist?

Du geht davon aus, daß erase() O(1) ist?

Ja:

Complexity
For the first version ( erase(position) ), amortized constant.

http://www.cplusplus.com/reference/stl/map/erase/

Unter gewissen Umständen könnte es wesentlich schneller sein, zusammenhängende Bereiche per range-erase abzuhandeln. Das verkompliziert allerdings den Algorithmus - Q, mit welchen Datenmengen wirfst du hier um dich? Lohnt sich der Aufwand?

Lohnt sich der Aufwand?

Nein.

Ich benutze dann doch einfach, das, was ich im ersten Post geschrieben hab.
Die Datenmengen sind nicht besonders groß, ich hatte eigentlich nur auf einen algorithmus aus <algorithm> gehofft, den es schon gibt und das ganze einfacht macht.

[...] ich hatte eigentlich nur auf einen algorithmus aus <algorithm> gehofft, den es schon gibt und das ganze einfacht macht.

Den gibt's doch.

Um die Vorzüge von seldons Code (set_difference) und campers Code (value_comp) zu kombinieren:

#include <algorithm>
#include <iostream>
#include <iterator>
#include <map>
#include <string>

int main() {
  std::map<int, std::string> m1, m2;

  m1[1] = "foo";
  m1[2] = "bar";
  m1[3] = "baz";

  m2[1] = "qux";
  m2[3] = "quux";
  m2[5] = "xyzzy";

  // "m1 aus m2 entfernen" ...
  {
    std::map<int, std::string> mt;
    std::set_difference(m2.begin(), m2.end(),
                        m1.begin(), m1.end(),
                        std::inserter(mt, mt.begin()),
                        m2.value_comp());
    m2.swap(mt);
  }

  for(auto i = m2.begin(); i != m2.end(); ++i) {
    std::cout << i->first << " -> " << i->second << '\n';
  }
}

kk