如何为大量数据生成哈希图？

Question

我想制作一个映射，使一组指针指向动态大小的数组。 我确实使用了带有链接的散列。但由于我使用它的数据量很大，因此程序在几次迭代后会给出std::bad_alloc。原因可能是new用于生成链表。

请有人建议我应该使用哪种数据结构？ 或者还有什么可以提高我的哈希表的内存使用率？

程序是 C++。

这是我的代码的样子： 哈希表的初始化：

class Link
{ 
  public:
         double iData; 
         Link* pNext; 
         Link(double it) : iData(it) 
         { }
         void displayLink()
         { cout << iData << " "; }
}; 

class List
 {
  private:
          Link* pFirst; 
  public:
         List() 
         { pFirst = NULL; }
         void insert(double key) 
         {

           if(pFirst==NULL)
           pFirst = new Link(key);
       else
          {
        Link* pLink = new Link(key);
        pLink->pNext = pFirst;
        pFirst = pLink;
       }

         }     

 }; 
class HashTable
{      
  public:
         int arraySize;
         vector<List*> hashArray; 

         HashTable(int size) 
         {

            hashArray.resize(size); 
            for(int j=0; j<size; j++) 
            hashArray[j] = new List; 
         }
};

主要的sn-p：

int t_sample = 1000;
 for(int i=0; i < k; i++)                                // initialize random position
{
        x[i] = (cal_rand() * dom_sizex);   //dom_sizex = 20e-10  cal_rand() generates rand no between 0 and 1
        y[i] = (cal_rand() * dom_sizey);    //dom_sizey = 10e-10
}

for(int t=0; t < t_sample; t++)
{
 int size;
 size = cell_nox * cell_noy; //size of hash table cell_nox = 212, cell_noy = 424

 HashTable theHashTable(size); //make table
 int hashValue = 0;

 for(int n=0; n<k; n++)   // k = 10*212*424
 {
  int m = x[n] /cell_width;     //cell_width = 4.7e-8
  int l = y[n] / cell_width;

   hashValue = (kx*l)+m;
   theHashTable.hashArray[hashValue]->insert(n); 

  }

   -------
   -------
 }

Answer 1

首先，使用标准容器。在您的具体情况下，您可能需要：

• std::unordered_multimap<int, double>
• 或std::unordered_map<int, std::vector<double>>

（注意：如果您没有 C++11，则在 Boost 中可用）

你的主循环变成（使用第二个选项）：

typedef std::unordered_map<int, std::vector<double>> HashTable;

for(int t = 0; t < t_sample; ++t)
{
    size_t const size = cell_nox * cell_noy;
       // size of hash table cell_nox = 212, cell_noy = 424

    HashTable theHashTable;
    theHashTable.reserve(size);

    for (int n = 0; n < k; ++n)   // k = 10*212*424
    {
        int m = x[n] / cell_width;     //cell_width = 4.7e-8
        int l = y[n] / cell_width;

        int const cellId = (kx*l)+m;

        theHashTable[cellId].push_back(n);
    }
}

这不会（可靠地）泄漏内存，尽管您当然可能有其他泄漏，因此会给您一个可靠的基线。它也可能比您的方法更快，界面更方便，等等......

一般而言，您不应该重新发明轮子，除非您有可用轮子未解决的特定需求，或者您实际上正在尝试学习如何创建轮子或创建更好的轮子。

Answer 2

操作系统必须解决与内存页面相同的问题，也许值得看看它是如何完成的？首先，假设所有页面都在磁盘上。一个页面是一个固定大小的内存块。对于您的用例，假设它是您的记录数组。由于 RAM 是有限的，操作系统会维护页码和它在 RAM 中的位置之间的映射。

因此，假设您的页面有 1000 条记录，并且您想访问记录 2024，您会向操作系统询问第 2 页，并从该页面读取记录 24。这样，您的地图大小只有 1/1000。

现在，如果您的页面没有映射到内存位置，那么它要么在磁盘上，要么之前从未被访问过（为空）。然后您需要换出另一个页面，并从磁盘加载该页面（并更新位置映射）。

这是对所发生情况的非常简化的描述，如果有人因为这样描述它而让我大吃一惊，我不会感到惊讶。

重点是：

这对你意味着什么？

首先，您的数据超出了 RAM - 如果您不想先尝试压缩，您将无法绕过写入磁盘。 其次，如果你愿意，你的链可以作为页面工作，但我想知道分页你的哈希码是否会更好。我的意思是，使用高位作为页码，使用低位作为页面中的偏移量。避免冲突仍然是关键，因为您希望加载尽可能少的页面。您仍然可以链接您的页面，并最终得到一个小得多的地图。 其次 - 一个关键部分是决定哪些页面要换掉，以便为新页面腾出空间。 LRU 应该没问题。如果您可以更好地预测您将（不需要）需要哪些页面，那么对您来说会更好。 第三 - 您需要页面的占位符来告诉您它们是在内存中还是在磁盘上。

希望这会有所帮助。