HashTable (search function) [closed] - c++

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 9 years ago.
#include <iostream>
#include <cstring>
#include <vector>
#include "list.cpp"
#include <cmath>
using namespace std;
struct HashEntry{
int key;
List<string> list;
HashEntry(int k)
{
key=k;
}
};
class Hash{
private:
HashEntry *Table[100];
int a;
public:
Hash(int A);
void insert(string word);
void Lookup(string word);
};
Hash::Hash(int A)
{
a=A;
}
void Hash::insert(string word)
{
int c=0;
for (int i=0;i<word.size();i++)
{
int b=(int)((a^i)*(word[i]));
c+=b;
}
c%=100;
List<string> list;
if (Table[c-1]==NULL) //if the respective bucket doesnot have any string
Table[c-1]=new HashEntry(c-1);
Table[c-1]->list.insertAtTail(word);
}
void Hash::Lookup(string word)
{
int c=0;
for (int i=0;i<word.size();i++)
{
int b=(int)((a^i)*(word[i]));
c+=b;
}
cout<<"one"<<endl;
c%=100;
Table[c-1]->list.searchFor(word);
cout<<"two"<<endl;
}
I am making a hash table using seperate chaining taking.my hash function is making a polynomial equation using a constant 'a' whose power is increasing with the index of the letter in a word.(a^0xb+a^1xb+a^2xb+...) , where b is a letter in the word which is being hashed and then I take mod(100) of the final answer.The problem i am facing is in lookup function.when I test the lookup function,the searchFor() function which is in part of part Linked list class does not work although it works fine on its own and i get an segmentation fault after the cout<<"one" which i used to debug .I am sorry for bothering but I just can't understand the problem here.The linked list class file is below.I am just pasting the function in which i am having problem
#ifndef __LIST_H
#define __LIST_H
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
/* This class just holds a single data item. */
template <class T>
struct ListItem
{
vector<string> words;
T value;
ListItem<T> *next;
ListItem<T> *prev;
ListItem(T theVal)
{
this->value = theVal;
this->next = NULL;
this->prev = NULL;
}
};
/* This is the generic List class */
template <class T>
class List
{
ListItem<T> *head;
public:
// Constructor
List();
// Copy Constructor
List(const List<T>& otherList);
// Destructor
~List();
// Insertion Functions
void insertAtHead(T item);
void insertAtTail(T item);
void insertAfter(T toInsert, T afterWhat);
void insertSorted(T item);
void printList();
// Lookup Functions
ListItem<T> *getHead();
ListItem<T> *getTail();
void *searchFor(T item);
// Deletion Functions
void deleteElement(T item);
void deleteHead();
void deleteTail();
// Utility Functions
int length();
};
#endif
template <class T>
void List<T>::searchFor(T item)
{
ListItem<T> *temp=head;
if (temp!=NULL)
{
while (temp->next!=NULL)
{
T sample=temp->value;
if (sample==item)
{
cout<<"String found";
return;
}
temp=temp->next;
}
T s=temp->value;
if (s==item)
{
cout<<"String found";
return;
}
}
}

Answer 1

In addition to my comment above, which led you to find one of the bugs you have, I will add this:
The reason why you crash is that your Hash class mismanages the hash table. First of all, you allocate an array of 100 HashEntry pointers:
HashEntry *Table[100];
Notice that you never set those pointers to anything - so they're pointing to who knows what. Perhaps they will, by sheer luck, point to NULL, but the chances of that are miniscule - you're way way way more likely to win the lottery. So, you are accessing some random memory - and that's bad.
The solution to that is to set each entry to NULL explicitly using a loop in your constructor. You will also need a destructor to free any allocated entries, so that you can delete it and not leak memory, because leaking is bad.
But an interesting question is why do it like that at all? Why not simply declare the buckets like this:
HashEntry Table[100];
That way all your buckets are allocated as part of the Hash object and you don't have to worry about dynamically allocating and deallocating buckets, checking pointers for NULL etc.
One problem with doing that is that your HashEntry constructor requires an int argument. It's unclear why that argument is necessary; I don't think that you need it and and you could just remove it.
This one change would have simplified your code dramatically and eliminated three bugs and the crash.