C++ 删除线性探测哈希表中的函数

我正在尝试使用线性探测冲突解决方法为我的哈希表编写一个适当的remove函数

我运行一个测试程序，从我的哈希表中删除几个记录。在某些情况下，我的find函数无法找到要删除的元素。然而，它应该还在桌子上。我认为我在remove（）中重新使用的方式是错误的

类

哈希表

包含成员

表

，一个类型为

记录

template <class TYPE>
struct Record{
    string key;
    TYPE value = NULL;
    Record(){
        key = "";
        value = 0;
    }
    Record(const char* key_, TYPE value_){

        key = key_;
        value = value_;
    }
    Record(string key_, TYPE value_){

        key = key_;
        value = value_;
    }

};

template <class TYPE>
bool HashTable<TYPE>::remove(const char* key){ 
    int tvalue; //temporary unused value to make find work

    if (find(key, tvalue))
    {
        table[lastFoundIdx].key = "";  //lastFoundIdx - index of element that contains a key
        table[lastFoundIdx].value = 0;
        numRec--;                        //reduce number of records in table
        int startIdx = lastFoundIdx;     //rehash will stat form start Index
        int i;
        if (lastFoundIdx == maxSize - 1) 
            i = 0;
        else
            i = lastFoundIdx + 1;

        while (table[i].key != ""&&i != maxSize){   // rehash starts here
            std::size_t h1 = std::hash<std::string>()(table[i].key);
            int hash = h1%maxSize;
            if (hash < i&&hash >= startIdx){
                table[startIdx].key = table[i].key;
                table[startIdx].value = table[i].value;
                table[i].key = "";
                table[i].value = 0;
                startIdx = i;
            }
            i++;
        }
        return true;
    }
    else return false;
}

模板
结构记录{
字符串键；
类型值=NULL；
记录（）{
key=“”；
数值=0；
}
记录（常量字符*键，类型值）{
key=key；
值=值；
}
记录（字符串键，类型值）{
key=key；
值=值；
}
};
模板
布尔哈希表：：删除（常量字符*键）{
int tvalue；//临时未使用的值，用于查找工作
if（查找（键，tvalue））
{
表[lastFoundIdx].key=”“；//lastFoundIdx-包含键的元素的索引
表[lastFoundIdx]。值=0；
numRec--；//减少表中的记录数
int startIdx=lastFoundIdx；//重新灰化将统计形成开始索引
int i；
if（lastFoundIdx==maxSize-1）
i=0；
其他的
i=lastFoundIdx+1；
而（表[i].key！=“”&&i！=maxSize）{//rehash从这里开始
std:：size\u t h1=std:：hash（）（表[i].key）；
int hash=h1%maxSize；
if（hash=startIdx）{
表[startIdx]。键=表[i]。键；
表[startIdx]。值=表[i]。值；
表[i]。键=”；
表[i]。数值=0；
startIdx=i；
}
i++；
}
返回true；
}
否则返回false；
}

这里还有我的find函数，它似乎工作得很好，但我可能错了

template <class TYPE>
    bool HashTable<TYPE>::find(const char* key, TYPE& value){
        std::size_t h1 = std::hash<std::string>()(key);
        int hash = h1%maxSize;
        int startIdx = hash;
        while (table[hash].key != "" && table[hash].key != key){
            hash = (hash + 1) % maxSize;
            if (hash == startIdx)
                return false;

        }
        if (table[hash].key == "")
            return false;
        else{
            lastFoundIdx = hash;
            value = table[hash].value;
            return true;
        }
    }

模板
布尔哈希表：：查找（常量字符*键、类型和值）{
std:：size\u t h1=std:：hash（）（键）；
int hash=h1%maxSize；
int startIdx=散列；
while（表[hash].key！=“和表[hash].key！=key）{
哈希=（哈希+1）%maxSize；
if（散列==startIdx）
返回false；
}
if（表[hash].key==“”）
返回false；
否则{
lastFoundIdx=散列；
value=表[hash]。值；
返回true；
}
}

---

你能帮我确定一下，我是不是在用正确的方式进行线性探测

表的类型是什么？@AndyG模板哈希表使用线性探测来解决冲突。当测试它时，像这个HashTable（hashtableMax）一样初始化它@Yochert你找到你要找的钥匙后为什么要重新洗牌？您只需找到记录，删除它，就是这样…@Pandrei散列函数可以为两个不同的键提供相同的值，然后记录将存储在表的下一个可用位置。因此，当我删除一条记录时，我需要确定它之后的任何记录是否应该放在这个位置。@Pandrei例如“cat”和“dog”具有相同的散列值=0。我把它们一个接一个地放在桌子上。所以“猫”进入表[0]，但“狗”无法进入，因为它已经被占用，所以进入表[1]。当我删除“cat”时，表[0]是空的，我需要将dog移到那个位置，因为它的散列值是0。否则，如果我要查找“dog”，则Find函数将转到表[0]，该表为空，并返回表中没有“dog”，但它是空的。