Hur man implementerar en exempelhashtabell i C/C++

Introduktion

En hashtabell är en datastruktur som används för att lagra data på ett sätt som gör det möjligt att hämta data snabbt baserat på en nyckel. Den fungerar genom att mappa nycklar till värden, där nycklarna är unika identifierare för varje dataelement. Att implementera en hashtabell i C/C++ kan vara en utmaning, men det är en värdefull färdighet för alla programmerare att ha.

Vad är en hashtabell?

En hashtabell består av en array av bucketer. Varje bucket är en kedjad lista som lagrar nyckel-värde-par. När en nyckel läggs till i hashtabellen beräknas ett hashvärde för nyckeln. Detta hashvärde används sedan för att bestämma vilken bucket nyckel-värde-paret ska lagras i.

Hur implementerar man en hashtabell i C/C++?

För att implementera en hashtabell i C/C++ följer du dessa steg:

1. Definiera hashtabellens struktur

Börja med att definiera hashtabellens struktur. Strukturen ska innehålla en array av bucketer, en storlek på arrayen och en hashfunktion.

2. Implementera hashfunktionen

Hashfunktionen är en funktion som tar en nyckel och returnerar ett hashvärde. Hashvärdet ska vara ett heltal som är jämnt fördelat över intervallet [0, storlek – 1].

3. Implementera infogningsfunktionen

Infogningsfunktionen lägger till ett nytt nyckel-värde-par i hashtabellen. Funktionen tar en nyckel och ett värde som argument och returnerar true om infogningen lyckades, annars false.

4. Implementera sökningsfunktionen

Sökningsfunktionen söker efter ett nyckel-värde-par i hashtabellen. Funktionen tar en nyckel som argument och returnerar värdet som är associerat med den nyckeln, eller null om nyckeln inte finns.

5. Implementera borttagningsfunktionen

Borttagningsfunktionen tar bort ett nyckel-värde-par från hashtabellen. Funktionen tar en nyckel som argument och returnerar true om borttagningen lyckades, annars false.

Exempel på implementering

Nedan följer ett exempel på implementering av en hashtabell i C/C++:

c++ #include <iostream> #include <vector> #include <list>


using namespace std;
struct HashTable {

  vector<list<pair<string, int>>> buckets;

  int size;

  hash<string> hashFunction;
  HashTable(int size) : buckets(size), size(size) {}
  int hash(string key) {

    return hashFunction(key) % size;

  }
  bool insert(string key, int value) {

    int bucketIndex = hash(key);

    auto it = find(buckets[bucketIndex].begin(), buckets[bucketIndex].end(),

                  make_pair(key, value));

    if (it != buckets[bucketIndex].end()) {

      return false;

    }

    buckets[bucketIndex].push_back(make_pair(key, value));

    return true;

  }
  int search(string key) {

    int bucketIndex = hash(key);

    auto it = find(buckets[bucketIndex].begin(), buckets[bucketIndex].end(),

                  make_pair(key, 0));

    if (it != buckets[bucketIndex].end()) {

      return it->second;

    }

    return -1;

  }
  bool remove(string key) {

    int bucketIndex = hash(key);

    auto it = find(buckets[bucketIndex].begin(), buckets[bucketIndex].end(),

                  make_pair(key, 0));

    if (it != buckets[bucketIndex].end()) {

      buckets[bucketIndex].erase(it);

      return true;

    }

    return false;

  }

};

int main() { HashTable hashTable(10); hashTable.insert("namn", "John Doe"); hashTable.insert("ålder", 30); cout << hashTable.search("namn") << endl; // John Doe cout << hashTable.search("ålder") << endl; // 30 hashTable.remove("namn"); cout << hashTable.search("namn") << endl; // -1 return 0; }

Slutsats

Att implementera en hashtabell i C/C++ kan vara en utmaning, men det är en värdefull färdighet för alla programmerare att ha. Genom att följa stegen i den här artikeln kan du skapa en effektiv och pålitlig hashtabell för dina egna program.

Vanliga frågor

1. Vad är fördelarna med att använda en hashtabell?
– Snabb hämtning och infogning
– Effektiv minnesanvändning
– Enkel att implementera
2. Vad är nackdelarna med att använda en hashtabell?
– Kan orsaka kollisioner
– Kräver att storleken bestäms i förväg
3. Vad är en kollision?
– En kollision uppstår när två olika nycklar mappas till samma bucket.
4. Hur hanteras kollisioner?
– Kollisioner kan hanteras med hjälp av kedjade listor, öppen adressering eller dubbla hashning.
5. Vad är en kedjad lista?
– En kedjad lista är en datastruktur som består av en sekvens av noder som är länkade tillsammans. Den används för att lagra nyckel-värde-par i en bucket.
6. Vad är öppen adressering?
– Öppen adressering är en teknik för att hantera kollisioner genom att söka efter en tom bucket i samma hashtabell.
7. Vad är dubbel hashning?
– Dubbel hashning är en teknik för att hantera kollisioner genom att använda två hashfunktioner för att generera ett hashvärde för en nyckel.
8. När ska jag använda en hashtabell?
– Hashtabeller är användbara när du behöver lagra data på ett sätt som gör det möjligt att hämta data snabbt baserat på en nyckel.
9. Vilka andra datastrukturer kan jag använda för att lagra data?
– Andra datastrukturer som du kan använda för att lagra data inkluderar binära sökträd, röda-svarta träd och B-träd.
10. Var kan jag lära mig mer om hashtabeller?
– Du kan lära dig mer om hashtabeller genom att läsa böcker, artiklar och online-resurser. Vissa användbara resurser inkluderar:
– Hashtabeller i C++
– Hashtabeller i C
– Implementera en hashtabell i C++ från grunden