hashtable

I'm implementing a hash table. The following is my function for initializing it. Im getting some errors which I cant understand why. I have also quoted what valgrind says. typedef struct HashTable { int size ; struct List *head; struct List *tail; }HashTable; typedef struct List { char *number; char *name; int time; struct List *next; }List; #define size_of_table 211 HashTable *createHashTable(void) { HashTable *new_table = malloc(sizeof(*new_table)*size_of_table); //line 606 if (new_table == NULL) { return NULL; } int i=0; for(i; i<size_of_table; i++) { new_table[i].size=0; new_table[i].head

I need a data structure that is ordered but also gives fast random access and inserts and removes. Linkedlists are ordered and fast in inserts and removes but they give slow random access. Hashtables give fast random access but are not ordered. So, it seems to nice to use both of them together. In my current solution, my Hashtable includes iterators of the list and the List contains the actual items. Nice and effective. Okay, it requires double the memory but that's not an issue. I have heard that some tree structures could do this also, but are they as fast as this solution? The most

I'm writing an array-backed hashtable in Java, where the type of key and value are Object; no other guarantee. The easiest way for me code-wise is to create an object to hold them: public class Pair { public Object key; public Object value; } And then create an array public Pair[] storage = new Pair[8]; But how does the jvm treat that in memory? Which is to say, will the array actually: be an array of pointers to Pair() objects sitting elsewhere, or contain the actual data? edit Since the objects are instantiated later as new Pair(), they're randomly placed in the heap. Is there any good way

I'm currently working on a hash table implementation in C. I'm trying to implement dynamic resizing, but came across a problem. If resizing a hash table means creating a new one with double (or half) the size, rehashing, and deleting the old one, how can I deal with old references the user may have made to the old table? Example code (I've omitted error checking just for this example): int main(int argc, char *argv[]) { ht = ht_create(5) /* make hashtable with size 5 */ ht_insert("john", "employee"); /* key-val pair "john -> employee" */ ht_insert("alice", "employee"); char *position = ht_get

What is the easiest way to traverse a hashtable's keys in ascending alphabetical order? This is fairly dependent upon what the type of the key is. But lets assume for a minute that they are strings. You could use the following LINQ query Hashtable table = GetHashTable(); var keys = table.Keys.Cast<String>().OrderBy(x => x); For more complex structures the LINQ query is only slightly different. Lets assume you had the following definition for a key struct Name { public string First; public string Last; // Equality code omitted } The LINQ code would be the following Hashtable table =

I have a hashtable that under heavy-traffic. I want to add timeout mechanism to hashtable, remove too old records. My concerns are, - It should be lightweight - Remove operation has not time critical. I mean (timeout value is 1 hour) remove operation can be after 1 hour or and 1 hour 15 minute. There is no problem. My opinion is, I create a big array (as ring buffer)that store put time and hashtable key, When adding to hashtable, using array index find a next slot on array put time, if array slot empty, put insertion time and HT key, if array slot is not empty, compare insertion time for