Hash-table - Tableau de liste Liée - C++

Je suis en train de créer une table de Hachage en utilisant un tableau sur linked-nœuds (faire une liste).
Mais je vais avoir des difficultés d'insertion d'une valeur dans la table de Hachage. Quand je le lance, j'obtiens ceci:

http://gyazo.com/3a28a70e66b3ea34e08223e5948f49c0.png

Voici mon code:

#include <iostream>
using namespace std;

class Node {
public:
  int num;
  Node * next;
};

class intHashTable {
private:
  int size;
  Node ** table;
public:
  intHashTable(int size);  //construct a new hash table with size elements
  ~intHashTable();     //delete the memory for all internal components
  void insert(int num);    //insert num into the hash table, no effect
               //if num is already in table
  void remove(int num);    //remove num from the hash table, no effect if not in table
  int lookup(int num);     //return 1 if num is already in table, 0 otherwise
  void print(void);        //print the elements of the hash table to the screen
};

//construct a new hash table with nelements elements
intHashTable::intHashTable(int nelements)
{
  size = nelements;
  table = new Node*[size];
  for ( int i = 0; i < size; i++ ) {
    table[i] = NULL;
  }
}

intHashTable::~intHashTable()
{
   for(int i=0; i<size; i++)
   {
      Node* temp = table[i];
      while(temp != NULL)
      {
         Node* next = temp->next;
         delete temp;
         temp = next;
      }
   }
   size = 0;
   delete[] table;
}

void intHashTable::insert(int num){
    int location = ((unsigned)num) % size;
    Node *runner = table[location];
    if(runner == NULL ){
    runner->num = num;
     }else{
        while(runner != NULL ){
            runner = runner->next;
        }
        runner->num = num;
    }
   }

int main(){
    intHashTable a (10);
    a.insert(2);
    return 0;
}
Est-il un debugger de Code::Blocks? il vous dira ce qui ne va pas...
En insert, coureur = tableau[lieu] est essentiellement NULLE, n'est-ce pas?
Lorsque vous exécutez dans un débogueur il n'y a pas d'erreurs ou d'avertissements ou de la pratique des traces de pile?
1 morceau de l'environnement 🙂 avis - à l'aide d'un débogueur vous donnera un avantage sur les autres étudiants qui ne sont pas - c'est quelque chose que j'ai toujours demander lors de l'entretien.
Aussi, votre nom est dans la capture d'écran, si cela vous ennuie, ayokunle.

OriginalL'auteur user1965283 | 2013-01-22

  1. 2

    la logique ici est faux

    int location = ((unsigned)num) % size;
Node *runner = table[location];

if(runner == NULL ) //if null u dereference it!
{
 runner->num = num;
}
else
{
  while(runner != NULL ) {  //u loop until null
    runner = runner->next;
  }
  runner->num = num;  //once u reach null u dereference it!
}

    je dirais plutôt:

    d'abord un ctor pour votre Noeud

    class Node {
public:
  int num;
  Node * next;

  Node( int _n ) : num(_n), next(NULL) { } 
};

    et puis

    if ( runner != NULL )
{
   while ( runner->next != NULL )
   {
      runner = runner->next;
   }
   runner->next = new Node( num );
}
else
{
  table[location] = new Node( num ); 
}

    OriginalL'auteur Anders

  2. 3

    Après la construction de intHashTable, tous les éléments de table sont encore NULL. Cependant, dans la fonction insert, un élément est déréférencé:

    Node *runner = table[location];
runner = runner->next;

    Ce fait planter le programme, parce que il est illégal de déréférencer un pointeur null.

    et si(coureur == NULL ){ runner->num = num; }
    Voir mon edit. Est-ce mieux?
    le meilleur de cas de test jamais
    Après runner = new Node(), le coureur ne sera jamais NULLE.
    Pukku mérite la grâce qu'il a vu le problème avant moi

    OriginalL'auteur Reunanen

  3. 1

    Ce code ne sera certainement pas le travail:

    if(runner == NULL ){
runner->num = num;

    Si le coureur est NULLE, alors vous ne devriez jamais déréférencement (à l'aide d' * ou ->).

    OriginalL'auteur Mats Petersson

  4. 1
    Node *runner = table[location];
runner = runner->next;
if(runner == NULL )

    Vous n'avez jamais vérifié si table[location] est null. Mais lors de la construction de votre table de hachage, il n'y a pas de nœuds à l'intérieur du nœud de la table (vous pouvez définir vous-même chaque entrée à null).

    Le problème avec ton code, c'est que vous ne pensez jamais à affecter votre nœud. Vous devriez faire

    Node* toInsert = new Node;
toInsert->next= NULL;
toInsert->num = num;

if(table[location]==NULL){
   table[location] = toInsert;  
}
else{
    Node *runner = table[location];
    while(runner->next != NULL){
         runner = runner->next;
    }
    runner->next = toInsert;
}

    OriginalL'auteur UmNyobe