Question

我目前正在构建一个哈希表，以便根据数据结构的运行时间来计算频率。 O（1）插入， O（n）更糟糕的查找时间等。

我问了几个人std::map和哈希表之间的区别，我得到了答案;

“std::map将元素添加为二叉树，从而导致 O（log n），其中哈希表实现它将是 O（n）的。“的

因此，我决定使用链接列表数组（用于单独链接）结构来实现哈希表。在下面的代码中，我为节点分配了两个值，一个是键（单词），另一个是值（频率）。它起作用;当索引为空时添加第一个节点时，它直接作为链接列表的第一个元素插入，频率为 0 。如果它已经在列表中（不幸的是， O（n）搜索时间）将其频率增加1.如果未找到，只需将其添加到列表的开头即可。

我知道实施中有很多流程，因此我想问一下这里有经验的人，为了有效地计算频率，如何改进这个实施？

到目前为止我编写的代码;

#include <iostream>
#include <stdio.h>

using namespace std;

struct Node {
    string word;
    int frequency;
    Node *next;
};

class linkedList
{
private:
    friend class hashTable;
    Node *firstPtr;
    Node *lastPtr;
    int size;
public:
    linkedList()
    {
        firstPtr=lastPtr=NULL;
        size=0;
    }
    void insert(string word,int frequency)
    {
        Node* newNode=new Node;
        newNode->word=word;
        newNode->frequency=frequency;

        if(firstPtr==NULL)
            firstPtr=lastPtr=newNode;
        else {
            newNode->next=firstPtr;
            firstPtr=newNode;
        }

        size++;
    }
    int sizeOfList()
    {
        return size;
    }
    void print()
    {
        if(firstPtr!=NULL)
        {
            Node *temp=firstPtr;
            while(temp!=NULL)
            {
                cout<<temp->word<<" "<<temp->frequency<<endl;
                temp=temp->next;
            }
        }
        else
            printf("%s","List is empty");
    }
};

class hashTable
{
private:
    linkedList* arr;
    int index,sizeOfTable;
public:
    hashTable(int size) //Forced initalizer
    {
        sizeOfTable=size;
        arr=new linkedList[sizeOfTable];
    }
    int hash(string key)
    {
        int hashVal=0;

        for(int i=0;i<key.length();i++)
            hashVal=37*hashVal+key[i];

        hashVal=hashVal%sizeOfTable;
        if(hashVal<0)
            hashVal+=sizeOfTable;

        return hashVal;
    }
    void insert(string key)
    {
        index=hash(key);
        if(arr[index].sizeOfList()<1)
            arr[index].insert(key, 0);
        else {
            //Search for the index throughout the linked list.
            //If found, increment its value +1
            //else if not found, add the node to the beginning
        }
    }



};

Answer 1

你关心最坏的情况吗？如果不是，请使用std::unordered_map（它处理冲突，你不需要multimap）或trie / critbit树（取决于键，它可能比哈希更紧凑，这可能是导致更好的缓存行为）。如果是，请使用std::set或trie。

如果您需要（例如，在线top-k统计信息），请在字典之外保留优先级队列。每个字典值包含出现次数以及该单词是否属于队列。队列复制了前k个频率/字对，但是按频率键入。每当您扫描另一个单词时，检查它是否（1）不在队列中，（2）是否比队列中的最小元素更频繁。如果是，请提取最小队列元素并插入刚刚扫描的队列元素。

如果愿意，您可以实现自己的数据结构，但从事STL实现的程序员往往非常敏锐。我会确保这是瓶颈的第一个。

Answer 2

1- std :: map和std :: set中搜索的复杂时间是O（log（n））。并且，std :: unordered_map和std :: unordered_set的缓冲时间复杂度为O（n）。但是，散列的恒定时间可能非常大，并且对于小数字变得大于log（n）。我总是考虑这张脸。

2-如果你想使用std :: unordered_map，你需要确保为你输入定义了std :: hash。否则你应该定义它。

哈希计算频率可以改善吗？

2 个答案: