2d向量和向量图之间有什么区别？

Question

Let's say I've declared

map< int , vector<int> > g1;
vector< vector<int> > g2;

What are the similarities and dissimilarities between these two ?

Answer 1

The similarity is the way you access data, it can be the same syntax:

std::cout << g1[3][2] << std::endl;
std::cout << g2[3][2] << std::endl;

The main difference is the following: the map of vector doesn't have to contain all the indices. Then, you can have, as example, only 3 vectors in your map accessed with keys '17', '1234' and 13579 :

g2[17].resize(10);
g2[1234].resize(5);
g2[13579].resize(100);

If you want the same syntax with a vector of vectors, you need to have at least 13579 vectors (including 13576 empty vector) in your main vector. But this will use a lot of unused space in the memory.

Moreover, in your map, you also can access your vectors with negative keys (which is not possible in the vector of vectors):

g2[-10].resize(10);

After this obviously high difference, the storage of data is different. The vector allocates contiguous memory, while the map is stored as tree. The complexity of access in the vector is O(1) , while it's O(log(n)) in the map. I invite you to learn some tutorial about containers in C++ to understand all the differences and the usual way to use them.

Answer 2

They are fundamentally different. While you may be able to do both g2[0] and g1[0] , the behavior is vastly different. Assume there is nothing at index 0, then std::map will default construct a new value_type, in this case a vector, and return a reference, whereas std::vector has undefined behavior, but typically either segfaults or returns garbage.

They are also completely different in terms of memory layout. While std::map is backed by a red-black tree, std::vector is contiguous in memory. So inserting into the map will always result in dynamic allocation somewhere in memory, whereas the vector would be resized in case its current capacity is exceeded. Note however, that a vector of vectors is not contiguous in memory. The first vector, which itself is contiguous in memory is made up of vectors which look roughly like this in terms of data:

struct vector 
{
    T* data;
    size_t capacity;
    size_t size;
};

Where each of the vectors owns its dynamic memory allocation at data .

The advantage of the map is that is does not have to be densely populated, ie you can have something at index 0 and 12902 without all the stuff in between, plus it is sorted. If you don't need the sorted property and can use c++11 consider std::unordered_map . The vector is always densely populated, ie at size 10000, elements 0-9999 exist.

Answer 3

With example you can understand the difference. Lets say the vector<int> stores unique ids of people, and map stores respective pincode as key.

map< int , vector<int> > listOfPeopleAtRespectivePinCode;
vector< vector<int> > bunchOfGroupsOfPeople;

Evidently, map are capable to associate key and value (here a list of values), while vector can efficiently store a bunch of data.