title: C programming question on the implementation of a hash table
body: <p>I have a C programming question on the implementation of a hash table. I have implemented the hash table for storing some strings.
  I am having a problem while dealing with hash collisons. I am following a chaining linked-list approach to overcome the problem but, somehow, my code is behaving differently. I am not able to debug it. Can somebody help?</p>
  
  <p>This is what I am facing:
  Say first time, I insert a string called gaur. My hash map calculates the index as 0 and inserts the string successfully. However, when another string whose hash also, when calculated, turns out to be 0, my previous value gets overrwritten i.e. gaur will be replaced by new string.</p>
  
  <p>This is my code:</p>
  
  <pre><code>struct list
  { 
   char *string;
   struct list *next; 
  };
  
  struct hash_table
  {
   int size;     /* the size of the table */
   struct list **table; /* the table elements */
  }; 
  
  struct hash_table *create_hash_table(int size)
  {
      struct hash_table *new_table;
      int i;
  
      if (size&lt;1) return NULL; /* invalid size for table */
  
      /* Attempt to allocate memory for the table structure */
      if ((new_table = malloc(sizeof(struct hash_table))) == NULL) {
          return NULL;
      }
  
      /* Attempt to allocate memory for the table itself */
      if ((new_table-&gt;table = malloc(sizeof(struct list *) * size)) == NULL) {
          return NULL;
      }
  
      /* Initialize the elements of the table */
      for(i=0; i&lt;size; i++) 
       new_table-&gt;table[i] = '\0';
  
      /* Set the table's size */
      new_table-&gt;size = size;
  
      return new_table;
  }
  
  
  unsigned int hash(struct hash_table *hashtable, char *str)
  {
      unsigned int hashval = 0;
      int i = 0;
  
      for(; *str != '\0'; str++)
      {
       hashval += str[i];
       i++;
      }
  
      return (hashval % hashtable-&gt;size);
  }
  
  struct list *lookup_string(struct hash_table *hashtable, char *str)
  {
      printf("\n enters in lookup_string \n");
  
      struct list * new_list;
      unsigned int hashval = hash(hashtable, str);
  
      /* Go to the correct list based on the hash value and see if str is
       * in the list.  If it is, return return a pointer to the list element.
       * If it isn't, the item isn't in the table, so return NULL.
      */
  
  
      for(new_list = hashtable-&gt;table[hashval]; new_list != NULL;new_list = new_list-&gt;next)
      {
          if (strcmp(str, new_list-&gt;string) == 0)
            return new_list;
      }
      printf("\n returns NULL in lookup_string \n");
      return NULL;
  }
  
  
  int add_string(struct hash_table *hashtable, char *str)
  {
      printf("\n enters in add_string \n");
  
      struct list *new_list;
      struct list *current_list;
      unsigned int hashval = hash(hashtable, str);
      printf("\n hashval = %d", hashval);
  
      /* Attempt to allocate memory for list */
      if ((new_list = malloc(sizeof(struct list))) == NULL)
      {
       printf("\n enters here \n");
       return 1;
      }
  
      /* Does item already exist? */
      current_list = lookup_string(hashtable, str);
  
      if (current_list == NULL)
      {
       printf("\n DEBUG Purpose \n");
       printf("\n NULL \n");
      }
  
      /* item already exists, don't insert it again. */
      if (current_list != NULL)
      {
       printf("\n Item already present...\n");
       return 2;
      }
  
      /* Insert into list */
      printf("\n Inserting...\n");
  
      new_list-&gt;string = strdup(str);
      new_list-&gt;next = NULL;
      //new_list-&gt;next = hashtable-&gt;table[hashval];
      if(hashtable-&gt;table[hashval] == NULL)
      {
        hashtable-&gt;table[hashval] = new_list;
      }
      else
      {
        struct list * temp_list = hashtable-&gt;table[hashval];
        while(temp_list-&gt;next!=NULL)
         temp_list = temp_list-&gt;next;
  
        temp_list-&gt;next = new_list;
        hashtable-&gt;table[hashval] = new_list;
      }
  
      return 0;
  }
  </code></pre>