实现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);
}