How to associate to a number another number without using array

Let's say we have read these values:

3
1241
124515
5322353
341
43262267234
1241
1241
3213131

And I have an array like this (with the elements above):

a[0]=1241
a[1]=124515
a[2]=43262267234
a[3]=3
...

The thing is that the elements' order in the array is not constant (I have to change it somewhere else in my program).

How can I know on which position does one element appear in the read document.

Note that I can not do:

vector <int> a[1000000000000];
a[number].push_back(all_positions);

Because a will be too large (there's a memory restriction). (let's say I have only 3000 elements, but they're values are from 0 to 2^32)

So, in the example above, I would want to know all the positions 1241 is appearing on without iterating again through all the read elements.

In other 开发者_开发技巧words, how can I associate to the number "1241" the positions "1,6,7" so I can simply access them in O(1) (where 1 actually is the number of positions the element appears)

If there's no O(1) I want to know what's the optimal one ... I don't know if I've made myself clear. If not, just say it and I'll update my question :)

You need to use some sort of dynamic array, like a vector (std::vector) or other similar containers (std::list, maybe, it depends on your needs).

Such data structures are safer and easier to use than C-style array, since they take care of memory management.

If you also need to look for an element in O(1) you should consider using some structures that will associate both an index to an item and an item to an index. I don't think STL provides any, but boost should have something like that.

If O(log n) is a cost you can afford, also consider std::map

You can use what is commonly refered to as a multimap. That is, it stores Key and multiple values. This is an O(log) look up time.

If you're working with Visual Studios they provide their own hash_multimap, else may I suggest using Boost::unordered_map with a list as your value?

You don't need a sparse array of 1000000000000 elements; use an std::map to map positions to values.

If you want bi-directional lookup (that is, you sometimes want "what are the indexes for this value?" and sometimes "what value is at this index?") then you can use a boost::bimap.

Things get further complicated as you have values appearing more than once. You can sacrifice the bi-directional lookup and use a std::multimap.

You could use a map for that. Like:

std::map<int, std::vector<int>> MyMap;

So everytime you encounter a value while reading the file, you append it's position to the map. Say X is the value you read and Y is the position then you just do

MyMap[X].push_back( Y );

Instead of you array use

std::map<int, vector<int> > a;

You need an associative collection but you might want to associated with multiple values.

You can use std::multimap< int, int >

or

you can use std::map< int, std::set< int > >

I have found in practice the latter is easier for removing items if you just need to remove one element. It is unique on key-value combinations but not on key or value alone.

If you need higher performance then you may wish to use a hash_map instead of map. For the inner collection though you will not get much performance in using a hash, as you will have very few duplicates and it is better to std::set.

There are many implementations of hash_map, and it is in the new standard. If you don't have the new standard, go for boost.

It seems you need a std::map<int,int>. You can store the mapping such as 1241->0 124515->1 etc. Then perform a look up on this map to get the array index.

Besides the std::map solution offered by others here (O(log n)), there's the approach of a hash map (implemented as boost::unordered_map or std::unordered_map in C++0x, supported by modern compilers).

It would give you O(1) lookup on average, which often is faster than a tree-based std::map. Try for yourself.

You can use a std::multimap to store both a key (e.g. 1241) and multiple values (e.g. 1, 6 and 7).

An insert has logarithmic complexity, but you can speed it up if you give the insert method a hint where it can insert the item.

For O(1) lookup you could hash the number to find its entry (key) in a hash map (boost::unordered_map, dictionary, stdex::hash_map etc)

The value could be a vector of indices where the number occurs or a 3000 bit array (375 bytes) where the bit number for each respective index where the number (key) occurs is set.

boost::unordered_map<unsigned long, std::vector<unsigned long>> myMap;
for(unsigned long i = 0; i < sizeof(a)/sizeof(*a); ++i)
{
   myMap[a[i]].push_back(i);
}

Instead of storing an array of integer, you could store an array of structure containing the integer value and all its positions in an array or vector.