C++ HashTable按指定键和元素删除的问题及解决方案求助

You want a Remove(int key, int value) function that deletes a specific value from the linked list associated with a given key in your HashTable. Your existing single-parameter Remove deletes the last inserted element for the key, but your attempt at the two-parameter version isn't working reliably. Let's break down the issues and fix this.

Issues with Your Current Two-Parameter Remove Implementation #

• Broken linked chain: When you delete entry, you don't adjust the previous node's next pointer to skip the deleted node. This leaves a dangling pointer and breaks the linked list structure.
• No head node handling: If the node to delete is the first one in the linked list (i.e., htable[hash_val] itself), you never update the hash table's pointer to the new head of the list.
• Missing error feedback: If the key doesn't exist or the value isn't found under that key, your function does nothing without letting you know.
• Unmanaged memory risks: You delete the node but don't ensure the rest of the list is properly connected, leading to potential crashes or memory leaks.

Corrected Implementation #

Here's a fixed version with comments explaining each critical step:

void HashTable::Remove(int key, int value) {
    int hash_val = HashFunc(key);
    HashNode* entry = htable[hash_val];
    HashNode* prev = nullptr;

    // Traverse the linked list to locate the target (key, value) pair
    while (entry != nullptr) {
        if (entry->key == key && entry->value == value) {
            // Case 1: Deleting the head node of the list
            if (prev == nullptr) {
                htable[hash_val] = entry->next; // Update the hash table's head pointer
            } 
            // Case 2: Deleting a middle or end node
            else {
                prev->next = entry->next; // Bypass the deleted node to keep the chain intact
            }
            
            // Clean up the deleted node's memory
            delete entry;
            cout << "Element (" << key << ", " << value << ") deleted successfully" << endl;
            return; // Exit after deleting the first match (remove this to delete all matches)
        }

        // Move to the next node while tracking the previous one
        prev = entry;
        entry = entry->next;
    }

    // If we exit the loop, the target element wasn't found
    cout << "No element with key " << key << " and value " << value << " found" << endl;
}

Key Improvements Explained #

• Track the previous node: Using prev lets us adjust the linked list pointers correctly when deleting a node, so the chain doesn't break.
• Handle head node deletion: When prev is nullptr, we know we're deleting the first node in the list—so we update the hash table's entry to point to the next node.
• Clear feedback: We print a success or failure message, so you know exactly what happened during the operation.
• Flexible matching: If your HashTable allows duplicate (key, value) pairs, just remove the return statement after deleting the node to delete all matching instances instead of just the first.

Optional Enhancements #

• Replace cout messages with a boolean return value (e.g., bool Remove(int key, int value)) so the caller can programmatically check if the deletion succeeded.
• Add const correctness where appropriate (e.g., if HashFunc doesn't modify the table, mark it as const).

内容的提问来源于stack exchange，提问作者Tommys Gian