hash = 0;
while ((ch = *key++)) hash = (17 * hash + ch) % size;

#include <stdio.h>
#include "../src/zhash.h"

// gcc -Wall -Wextra hello.c ../src/zhash.c
// prints "hello world" to stdout
int main ()
{
  struct ZHashTable *hash_table;

  hash_table = zcreate_hash_table();

  zhash_set(hash_table, "hello", (void *) "world");

  if (zhash_exists(hash_table, "hello")) {
    printf("hello %s\n", (char *) zhash_get(hash_table, "hello"));
  }

  if (zhash_exists(hash_table, "goodbye")) {
    printf("goodbye %s\n", (char *) zhash_get(hash_table, "goodbye"));
  }

  zfree_hash_table(hash_table);

  return 0;
}

// create hash table
struct ZHashTable *zcreate_hash_table(void);

// free hash table (note that this only frees the table and the entry structs)
void zfree_hash_table(struct ZHashTable *hash_table);

// set key to val (if there is already a value, overwrite it)
void zhash_set(struct ZHashTable *hash_table, char *key, void *val);

// get the value stored at key (if no value, return NULL)
void *zhash_get(struct ZHashTable *hash_table, char *key);

// delete entry stored at key and return the value (if no value, return NULL)
void *zhash_delete(struct ZHashTable *hash_table, char *key);

// return true if there is a value stored at the key and false otherwise
bool zhash_exists(struct ZHashTable *hash_table, char *key);

#include <stdio.h>
#include "../src/zsorted_hash.h"

// gcc -Wall -Wextra sorted_hello.c ../src/zhash.c ../src/zsorted_hash.c
// prints "hello world" in English and French to stdout
int main ()
{
  struct ZSortedHashTable *hash_table;
  struct ZIterator *iterator;

  hash_table = zcreate_sorted_hash_table();

  zsorted_hash_set(hash_table, "hello", (void *) "world");
  zsorted_hash_set(hash_table, "bonjour", (void *) "le monde");

  for (iterator = zcreate_iterator(hash_table);
      ziterator_exists(iterator); ziterator_next(iterator)) {

    printf("%s %s\n", ziterator_get_key(iterator),
        (char *) ziterator_get_val(iterator));
  }

  zfree_iterator(iterator);
  zfree_sorted_hash_table(hash_table);

  return 0;
}

// these functions behave the same as their counterparts in zhash.h
struct ZSortedHashTable *zcreate_sorted_hash_table(void);
void zfree_sorted_hash_table(struct ZSortedHashTable *hash_table);
void zsorted_hash_set(struct ZSortedHashTable *hash_table, char *key, void *val);
void *zsorted_hash_get(struct ZSortedHashTable *hash_table, char *key);
void *zsorted_hash_delete(struct ZSortedHashTable *hash_table, char *key);
bool zsorted_hash_exists(struct ZSortedHashTable *hash_table, char *key);

// create an iterator to be used in iteration functions below
struct ZIterator *zcreate_iterator(struct ZSortedHashTable *hash_table);

// free iterator
void zfree_iterator(struct ZIterator *iterator);

// return number of entries stored in the hash table
size_t zsorted_hash_count(struct ZSortedHashTable *hash_table);

// return true if the iterator is within bounds and false otherwise
bool ziterator_exists(struct ZIterator *iterator);

// get the key at the current position (if out of bounds, then return NULL)
char *ziterator_get_key(struct ZIterator *iterator);

// get the value at the current position (if out of bounds, then return NULL)
void *ziterator_get_val(struct ZIterator *iterator);

// move the position forward by one step
void ziterator_next(struct ZIterator *iterator);

// move the position back by one step
void ziterator_prev(struct ZIterator *iterator);