实现hashmap

/*
*数组下面挂着链表
*/
 
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include<memory.h>
 
#define uint32  unsigned int
#define size_t  unsigned int
#define uchar   unsigned char
 
uint32 bucknum=;
 
typedef struct data{
    uint32 key;
    char msg[];
    struct data* next;
}DATA;
 
typedef struct{
    uint32 len;
    DATA* data;
}BUCKET;
 
BUCKET* buckets=NULL;
 
void initMap(uint32* num,BUCKET* dst){
    dst=(BUCKET*)malloc(sizeof(BUCKET)*(*num));
    memset(dst,,sizeof(BUCKET)*(*num));
}
 
uint32 hashKey(uchar* p ,size_t len){
    uint32 key=;
    for(int i=;i<len;i++){
        key=key*+*(p+i);
    }
    return key;
}
 
int mapSize(BUCKET* bucket,size_t len){
    int sum=;
    for(int i=;i<len;i++){
        sum+=bucket[i].len;
    }
    return sum;
}
 
void put(BUCKET* bucket,size_t size,uint32 key,DATA* data){
    int index=key%size;
    data->key=key;
        if(bucket[index].len==){
            bucket[index].data=data;
            bucket[index].len++;
            return;
        }else{
            DATA* top = bucket[index].data;
            DATA* below = bucket[index].data;
            int count=;
            do{
                if(below->key==key){
                    if(count==){
                        bucket[index].data=data;
                        data->next=below->next;
                        free(below);
                        below=data;
                    }else{
                        top->next=data;
                        data->next=below->next;
                        free(below);
                        below=data;
                        free(below);
                    }
                    break;
                }else{
                    if(below->next!=NULL){
                         top=below;
                        below=below->next;
                     }else{
                        below->next=data;
                        bucket[index].len++;
                        break;
                    }
                }
                count++;
            }while();
        }
}
 
void destroy(BUCKET* buck,size_t len){
    for(int i=;i<len;i++){
        DATA* bc=buck[i].data;
        while (bc!=NULL) {
            DATA* tem=bc;
            bc=bc->next;
            free(tem);
        }
    }
    free(buck);
}
 
void entryExtend(BUCKET* oldbucket,size_t* newlen,size_t oldlen){
    BUCKET* newbucket=NULL;
    *newlen=(*newlen)<<;
    initMap(*newlen,newbucket);
 
    for(int i=;i<oldlen;i++){
        DATA* bc=oldbucket[i].data;
        while (bc!=NULL) {
            put(newbucket,*newlen,bc->key,bc);
            bc=bc->next;
        }
    }
 
    destroy(oldbucket,oldlen);
    oldbucket=newbucket;
}
 
/*
void put(BUCKET* bucket,char* key,size_t len,DATA* data){
    uint32 k = hashKey(key,len);
    uint32 index = k % buck_num;
    data->key=k;
        if(bucket[index].len==0){
            bucket[index].data=data;
            bucket[index].len++;
            return;
        }else{
            DATA* top = bucket[index].data;
            DATA* below = bucket[index].data;
            int count=0;
            do{
                if(below->key==k){
                    if(count==0){
                        bucket[index].data=data;
                        data->next=below->next;
                        free(below);
                        below=data;
                    }else{
                        top->next=data;
                        data->next=below->next;
                        free(below);
                        below=data;
                        free(below);
                    }
                    break;
                }else{
                    if(below->next!=NULL){
                         top=below;
                        below=below->next;
                     }else{
                        below->next=data;
                        bucket[index].len++;
                        break;
                    }
                }
                count++;
            }while(1);
        }
}
*/
 
int main(){
    initMap(&bucknum,buckets);
 
    destroy(buckets,bucknum);
}