Help! hash table

[Eraphine Astrid]

problem with searching. it has infinity loop when try to search..
and what should i use if i wan to change the user input to internal array, using strcmp?

anyone please help me~ thank you

#include <stdio.h>
  #include <string.h>
  #include <stdlib.h>

  struct hash *hashTable = NULL;
  int eleCount = 0;

  struct node {
        int key, age;
        char name[100];
        struct node *next;
  };

  struct hash {
        struct node *head;
        int count;
  };

  struct node * createNode(int key, char *name, int age) {
        struct node *newnode;
        newnode = (struct node *)malloc(sizeof(struct node));
        newnode->key = key;
        newnode->age = age;
        strcpy(newnode->name, name);
        newnode->next = NULL;
        return newnode;
  }


  void insertToHash(int key, char *name, int age) {
        int hashIndex = key % eleCount;
        struct node *newnode =  createNode(key, name, age);
        /* head of list for the bucket with index "hashIndex" */
        if (!hashTable[hashIndex].head) {
                hashTable[hashIndex].head = newnode;
                hashTable[hashIndex].count = 1;
                return;
        }
        /* adding new node to the list */
        newnode->next = (hashTable[hashIndex].head);
        /*
         * update the head of the list and no of
         * nodes in the current bucket
         */
        hashTable[hashIndex].head = newnode;
        hashTable[hashIndex].count++;
        return;
  }


  void deleteFromHash(int key) {
        /* find the bucket using hash index */
        int hashIndex = key % eleCount, flag = 0;
        struct node *temp, *myNode;
        /* get the list head from current bucket */
        myNode = hashTable[hashIndex].head;
        if (!myNode) {
                printf("Given data is not present in hash Table!!\n");
                return;
        }
        temp = myNode;
        while (myNode != NULL) {
                /* delete the node with given key */
                if (myNode->key == key) {
                        flag = 1;
                        if (myNode == hashTable[hashIndex].head)
                                hashTable[hashIndex].head = myNode->next;
                        else
                                temp->next = myNode->next;

                        hashTable[hashIndex].count--;
                        free(myNode);
                        break;
                }
                temp = myNode;
                myNode = myNode->next;
        }
        if (flag)
                printf("Data deleted successfully from Hash Table\n");
        else
                printf("Given data is not present in hash Table!!!!\n");
        return;
  }

  void searchInHash(int key) {
        int hashIndex = key % eleCount, flag = 0;
        struct node *myNode;
        myNode = hashTable[hashIndex].head;
        if (!myNode) {
                printf("Search element unavailable in hash table\n");
                return;
        }
        while (myNode != NULL) {
                if (myNode->key == key) {
                        printf("VoterID  : %d\n", myNode->key);
                        printf("Name     : %s\n", myNode->name);
                        printf("Age      : %d\n", myNode->age);
                        flag = 1;
                        break;
                }
                myNode = myNode->next;
        }
        if (!flag)
                printf("Search element unavailable in hash table\n");
        return;
  }

  void display() {
        struct node *myNode;
        int i;
        for (i = 0; i < eleCount; i++) {
                if (hashTable[i].count == 0)
                        continue;
                myNode = hashTable[i].head;
                if (!myNode)
                        continue;
                printf("\nData at index %d in Hash Table:\n", i);
                printf("VoterID     Name          Age   \n");
                printf("--------------------------------\n");
                while (myNode != NULL) {
                        printf("%-12d", myNode->key);
                        printf("%-15s", myNode->name);
                        printf("%d\n", myNode->age);
                        myNode = myNode->next;
                }
        }
        return;
  }

  int main() {
        int n, ch, key, age;
        char name[100];
        printf("Enter the number of elements:");
        scanf("%d", &n);
        eleCount = n;
        /* create hash table with "n" no of buckets */
        hashTable = (struct hash *)calloc(n, sizeof (struct hash));
        while (1) {
                printf("\n1. Insertion\t2. Deletion\n");
                printf("3. Searching\t4. Display\n5. Exit\n");
                printf("Enter your choice:");
                scanf("%d", &ch);
                switch (ch) {
                        case 1:
                                printf("Enter the key value:");
                                scanf("%d", &key);
                                getchar();
                                printf("Name:");
                                fgets(name, 100, stdin);
                                name[strlen(name) - 1] = '\0';
                                printf("Age:");
                                scanf("%d", &age);
                                /*inserting new node to hash table */
                                insertToHash(key, name, age);
                                break;

                        case 2:
                                printf("Enter the key to perform deletion:");
                                scanf("%d", &key);
                                /* delete node with "key" from hash table */
                                deleteFromHash(key);
                                break;

                        case 3:
                                printf("Enter the key to search:");
                                scanf("%d", &key);
                                searchInHash(key);
                                break;
                        case 4:
                                display();
                                break;
                        case 5:
                                exit(0);
                        default:
				printf("U have entered wrong option!!\n");
                                break;
					 }
		  }  

  }

[cire]

problem with searching. it has infinity loop when try to search..

Perhaps you can supply the input sequence that causes the infinite loop? I don't see anything obvious.

[Eraphine Astrid]

that one solved dy.. but if i wan to hav information that exist inside the program such as
1. key=sam, value = paul
2. key=kit, value = ivan
3. key=web, value=spider

how can i put the informations for key1 and value1 linking together in the hash table?

i cant find the example anywhere..

[dhayden]

I'm assuming that you mean each node has a key and a value. I'm also assuming that you want to look up the nodes based on the key and do it using a hash table.

So your node should look something like this:

struct node {
        int key, age;
        char name[100];
        char keyword[20];
        char value[30];
        struct node *next;
  };

BTW, you probably should use string instead of a char array since string can hold any number of characters.

Okay, now the part that you're missing is the hash function. This takes the keyword (the string that you want to look things up with) and creates a number that you'll use as the hash key:

struct node {
        int hash() const;
        ...
};

int node::hash() const
{
    int result = 0;
    for (const char *cp = keywd; *cp; ++cp) {
        result += *cp;
    }
    return result;
}

Important note! The example hash function isn't very good. For example, it will produce the same hash value for keywords "cat" and "tac". Choosing a good hash function is critical to the performance of the hash table.

Change createNode to take the keyword and value. It should compute the hash key. Better still, make this a constructor in struct node:

node::node(const char *namep, int agep, const char *keyp, const char *valp)
{
    strcpy(name, namep);
    age = agep;
    strcpy(keywd, keyp);
    strcpy(value, valp);
    key = hash();
}

Replace InsertToHash() with a function that takes a reference to a node. Let the caller create the node:

InsertToHash(node &newnode)
{
        int hashIndex =newnode. key % eleCount;
        /* head of list for the bucket with index "hashIndex" */
        if (!hashTable[hashIndex].head) {
                hashTable[hashIndex].head = &newnode;
                hashTable[hashIndex].count = 1;
                return;
        }
        // etc
}

Add search and delete methods that take a keyword. These can call your existing functions. For example:

void searchInHash(const char *k)
{
    node dummy("", 0, k, "");
    searchInHash(dummy.key);
}

As a final comment, I'll point out that this would be better if there were a HashTable class with insert/delete/search methods. The table array would be private data.