Human: Can you implement a hash table data structure in C, and write functions to insert, delete, and search elements in the table, and explain how it works and what are its advantages and disadvantages?

Assistant: Hash tables are a data structure that allows fast access to key/value pairs. The basic idea is to use a hash function to map the keys to array indices, where the values can be stored. The advantage of this approach is that you can perform insertions, deletions, and searches in constant time on average.

To implement a hash table in C, you first need to write the hash function. One common strategy is to use modulo arithmetic with a prime number as the size of the table:

```c
int hash(char* key, int table_size) {
    int hash_value = 0;
    while (*key) {
        hash_value = (hash_value * 31 + *key) % table_size;
        key++;
    }
    return hash_value;
}
```

This function takes a string `key` and a `table_size` parameter (which should be a prime number), and computes an index into the table by iterating over each character in the key and accumulating their ASCII values.

Next you need to create a struct for each element of the hashtable:

```c
struct entry {
    char* key;
    int value;
};
```

Now we can define our hashtable structure as an array of entries, along with two more fields: `size`, which stores the current number of elements in the table, and `capacity`, which stores its total capacity:

```c
struct hashtable {
    struct entry* entries;
    int size;
    int capacity;
};
```

To insert an element into our hashtable is simple using our defined functions:

```c
void insert(struct hashtable* ht, char* key, int value) {
  	int idx = hash(key, ht->capacity);
    
  	while(ht->entries[idx].key != NULL){
        
      	if(strcmp(ht->entries[idx].key,key)==0){
      		// Found matching key so updating.
        		ht->entries[idx].value=value;
        		return ;
      	}
  		
    		idx = (idx+1)%ht->capacity;  
        
  	}
    ht->entries[idx]=(struct entry){key,value};
  	ht->size++;
    if(ht->capacity*0.7 <= ht->size){
        ht=grow_ht(ht);
    }
}
```

This function calculates the hash value of the given key and then search for an empty place in hashtable which is [Linear probing](https://en.wikipedia.org/wiki/Linear_probing). If it finds the same key, it updates it else inserts a new record. It grow the hashtable when capacity is lower than number of ELEM_SIZE(percentage should be your decision).

Now let's create a function to retrieve data from our hash table:

```c
int* search(struct hashtable* ht, char* key) {
    int idx = hash(key, ht->capacity);
    
    while (ht->entries[idx].key != NULL) {
        if (strcmp(ht->entries[idx].key, key) == 0) {
            return &ht->entries[idx].value;
        }
        
        idx = (idx + 1) % ht->capacity;
    }
    
    return NULL;
}
```

The `search` function works by calculating the index using the `hash` function and linear probing until either an entry with a matching key is found or an empty cell is encountered.

Lastly we can create a delete function:

```c
void delete(struct hashtable* ht, char *key){
  int idx=hash(key,ht->capcity);
  while(ht.entries[idx].key!=NULL){
      if(strcmp(key,ht.entries[idx].key)){
          // Found matching element so deleting.
          free(ht.entries[i].name); 
          memset(&ht.entries[i], '\0', sizeof(struct entry));
          return i;
      }
      idx = (idx + 1) % ht.capacity;

  }
}
```

This `delete` function works by looking for the index of the key in a hash table, if it found then we release occupied memory space of that entry and mark is as null.

In terms of advantages hash tables have fast insertion, deletion, and search times compared to other data structures. They are great for situations where you need to look up data by key quickly.

However there can be some disadvantages with collisions/issues occurring from bad keys or a busy hash-table with too many elements. But with effort on choosing right hashing and collison practice can help mitigate those issues effectively.