Re: How is map<vector<int>, int> stored? (for graph algorithms)
On Nov 8, 10:35 pm, Digital Puer <digital_p...@hotmail.com> wrote:
On Nov 8, 1:11 pm, Joshua Maurice <joshuamaur...@gmail.com> wrote:
On Nov 8, 10:19 am, "AnonMail2...@gmail.com" <anonmail2...@gmail.com>
wrote:
On Nov 8, 12:55 pm, Digital Puer <digital_p...@hotmail.com> wrote:
On Nov 7, 11:51 pm, Vaclav Haisman <v.hais...@sh.cvut.cz> wrote:
Digital Puer wrote, On 8.11.2009 6:34:
I am trying to implement some graph algorithms, and I need
to manage a typical weighted adjacency data structure,
such that A[v1, v2] = w, where w is the weight of the
directed edge that connects vertex v1 to vertex v2.
I know the standard implementations of this data structure,
namely the adjacency matrix and the adjacency list.
http://en.wikipedia.org/wiki/Adjacency_matrix
http://en.wikipedia.org/wiki/Adjacency_list
Then I got to thinking how C++ STL would handle the
following:
map<vector<int>, int> A;
int v1, v2, w;
vector<int> edge;
edge.push_back(v1);
edge.push_back(v2);
A[edge] = w;
Yes, I know that I can use pair<int, int> instead of
vector<int>.
More logical than either would be to define an Edge class. But
vector is a very poor approximation of an edge, since it can
have any number of values, not just exactly two.
How does STL internally manage map<vector<int>, int>
or map<pair<int, int>, int>?
How well does they compare in memory and lookup time
to an adjacency matrix and an adjacency list?
Using std::vector<> as a key for two integere elements
is very suboptimal. There is extra indirection, which
means its copy ctor and other operations have lots
more overhead than that of std::pair<>. Also,
sizeof(std::vector<int>) > sizeof(std::pair<int,int>).
The access to the elements is harder, too.
Instead of std::vector<>, use either the std::pair<>
or your own Edge class.
How does STL hash pair<int, int> for use as a map key?
std::map uses the operator<() (less than) function to
order it's elements. The term hash does not apply.
std::pair defines this as:
Well, C++03 the term hash does not apply. For TR2 or C++0x,
we're getting hash sets and hash maps, so it does apply in
these cases. However, the OP is still wrong as he implied
that std::map is a hash map. It is not. It is a red-black
binary tree (or at least almost certainly is because of the
complexity requirements in the standard).
It's not necessarily a red-black tree, but in practice, it must
be some form of more or less balanced tree to meet the
complexity requirements.
By "hash", I meant to ask how are the keys compared? For a
map<vector<int>, int>, how would the keys be compared?
Straightforward lexographical comparison.
I assume the comparer must walk down both vectors and do
element-wise comparison, and if two vectors are the same
through N elements but one vector is longer, then the shorter
one wins the comparison?
Exactly.
Note that that's more or less what std::pair does as well.
Except that one pair will never be longer than the other, and
since the class knows the length, and the length is small, it
won't bother with a loop, but will simply do the two
comparisons.
--
James Kanze