在內存使用方面，c ++中的map和unordered_map有什么區別嗎？

Question

我在InterviewBit上解決了一個問題並遇到了一個問題，這里是鏈接https://www.interviewbit.com/problems/diffk-ii/ 。 當我使用c ++ STL map來解決這個問題時，它會向我顯示消息

內存限制超出。 您的提交未在分配的內存限制中完成。 這是我的代碼

int Solution::diffPossible(const vector<int> &A, int B) {
    int n = A.size();
    map< int , int > mp;
    for(int i =0;i<n; i++)
        mp[A[i]] = i;
    int k = B;
    for(int i =0; i<n; i++){
        if(mp.find(A[i]+k) != mp.end() && mp[A[i]+k] != i){
            return 1;
        }
        if(mp.find(A[i]-k) != mp.end() && mp[A[i]-k] != i){
            return 1;
        }
    }

    return 0;
}

當我用unorderd_map解決方案替換map時接受了。 這是代碼

int Solution::diffPossible(const vector<int> &A, int B) {
    int n = A.size();
    unordered_map< int , int > mp;
    for(int i =0;i<n; i++)
        mp[A[i]] = i;
    int k = B;
    for(int i =0; i<n; i++){
        if(mp.find(A[i]+k) != mp.end() && mp[A[i]+k] != i){
            return 1;
        }
        if(mp.find(A[i]-k) != mp.end() && mp[A[i]-k] != i){
            return 1;
        }
    }

    return 0;
}

這意味着map比unordered_map占用更多內存。 任何人都可以解釋這是怎么回事？ 為什么map比unordered_map占用更多的內存空間？

Answer 1

1. 映射被實現為二進制搜索樹，並且每個節點（除了有用數據之外）通常存儲3個指針 （對於左子節點，右子節點和父節點）。

2. 無序映射實現為哈希表 ，其中每個節點都在鏈表中。 在單鏈表（屬於相關桶）的情況下，每個節點只有1個指針 。 更新 ：但是，每個存儲桶還有一個額外的指針。 在沒有沖突的理想情況下，每個元素存儲2個指針存儲在內存中。

注意，2個int通常占用8個字節，與單個指針相同。

---

例如，查看GNU libstdc ++實現。 RB樹的節點定義如下：

struct _Rb_tree_node_base
{
  typedef _Rb_tree_node_base* _Base_ptr;
  typedef const _Rb_tree_node_base* _Const_Base_ptr;

  _Rb_tree_color    _M_color;
  _Base_ptr     _M_parent;
  _Base_ptr     _M_left;
  _Base_ptr     _M_right;
  ...

在那里，你可以觀察到這三個指針。

---

通常，很難說哪個容器會消耗更少的總體內存。 但是，我創建了一個基准，將1M隨機數插入到兩個容器中並測量最大駐留大小 （MaxRSS）以反映所有消耗的內存空間，包括例如堆內務數據。 結果如下：

1. 48,344 kB for std::map ，
2. 50 888 kB for std::unordered_map ，
3. 40,932 kB for std::unordered_map with reserve 。

請注意，由於存儲桶列表的重新分配，無序映射（廣告2）的內存消耗較高。 這就是reserve會員職能的用途。 如果一個人關心內存消耗並事先知道元素的數量，他/她應該總是預先分配（這與向量的情況相同）。

Answer 2

映射基本上是二叉搜索樹，而unordered_map實現為哈希映射。 如果你看看兩者的實現，你會很快注意到BST要大得多。

這也意味着map比unordered_map慢很多。

                | map             | unordered_map
---------------------------------------------------------
Ordering        | increasing  order   | no ordering
                | (by default)        |

Implementation  | Self balancing BST  | Hash Table
                | like Red-Black Tree |  

search time     | log(n)              | O(1) -> Average 
                |                     | O(n) -> Worst Case

Insertion time  | log(n) + Rebalance  | Same as search

Deletion time   | log(n) + Rebalance  | Same as search

BST：

struct node
{
    int data;
    node* left;
    node* right;
};

HashMap的：

struct hash_node {
    int key;
    int value;
    hash_node* next;
}

參考： https ： //www.geeksforgeeks.org/map-vs-unordered_map-c/