Hash Tables

int delete_string(hash_table_t *hashtable, char *str)
{
	int i;
	list_t *list, *prev;
	unsigned int hashval = hash(str);

	/* find the string in the table keeping track of the list item
	 * that points to it
	 */
	for(prev=NULL, list=hashtable->table[hashval];
		list != NULL && strcmp(str, list->str);
		prev = list,
		list = list->next);
	
	/* if it wasn't found, return 1 as an error */
	if (list==NULL) return 1; /* string does not exist in table */

	/* otherwise, it exists. remove it from the table */
	if (prev==NULL) hashtable[hashval] = list->next;
	else prev->next = list->next; 
	
	/* free the memory associate with it */
	free(list->str);
	free(list);

	return 0;
}

int count_strings(hash_table_t *hashtable)
{
	int i, count = 0;
	list_t *list;

	/* error check to make sure hashtable exists */
	if (hashtable==NULL) return -1;

	/* go through every index and count all list elements in each index */
	for(i=0; i<hashtable->size; i) {
		for(list=hashtable[i]; list != NULL; list = list->next) count;
	}

	return count;
}

All we'd have to do is modify the linked list structure to include all that information:

typedef struct _list_t_ {
	char *name; /* and of course we'd have to change our code to use name */
	int grad_year;
	char letter_grade;
	struct _list_t_ *next;
} list_t;

Just like in the count function above, you could do a linear search of the hash table until you found what you were looking for. But this is incredibly inefficient when compared to the normal hash lookup efficiency of O(1) . Since we're essentially doing a linear search through n strings, the efficiency of this strategy is O(n) .

Linear probing insertion could be O(n) , while separate chaining is O(1) as you always insert at the beginning of the list.