Hash表

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;

#define SUCCESS 1
#define UNSUCCESS 0
#define DUPLICATE -1

#define EQ(a,b) (!strcmp((a),(b)))

typedef struct{
	char key[10];
}ElemType;

typedef struct{
	ElemType *elem;
	int count;
	int sizeindex;
}HashTable;

Status initHashTable(HashTable &H);

Status RecreateHashTable(HashTable &H,ElemType e);

void RecreateHashTable(HashTable &H);

Status SearchHash(HashTable H,char* key,int &p,int &c);

Status InsertHash(HashTable &H,ElemType e);

int Hash(HashTable H,char* key);

void collision(HashTable H,int &p,int &c);

int hashsize[4] = {11,19,29,37};

Status initHashTable(HashTable &H){
	int i;
	H.count = 0;
	H.sizeindex = 0;
	H.elem = (ElemType *)malloc(hashsize[H.sizeindex]*sizeof(ElemType));
	if(!H.elem) return ERROR;
	for(i=0;i<hashsize[H.sizeindex];i++){
		H.elem[i].key[0] = '\0';
	}
	return OK;
}

Status RecreateHashTable(HashTable &H,ElemType e){
	int i,n=0;
	ElemType *p = (ElemType *)malloc(H.count*sizeof(ElemType));
	if(!p) return ERROR;
	for(i=0;i<hashsize[H.sizeindex];i++){
		if(H.elem[i].key[0] != '\0') {
			p[n++] = H.elem[i];
		}
	}
	H.count = 0;
	H.sizeindex++;
	free(H.elem);
	H.elem = NULL;
	H.elem = (ElemType *)malloc(hashsize[H.sizeindex]*sizeof(ElemType));
	if(!H.elem) return ERROR;
	for(i=0;i<hashsize[H.sizeindex];i++){
		H.elem[i].key[0] = '\0';
	}
	for(i=0;i<n;i++){
		InsertHash(H,p[i]);
	}
	InsertHash(H,e);
	free(p);
	p = NULL;
	return OK;
}

Status SearchHash(HashTable H,char* key,int &p,int &c){
	p = Hash(H,key);
	while(H.elem[p].key[0] != '\0' && !EQ(key,H.elem[p].key)) collision(H,p,++c);
	if(EQ(key,H.elem[p].key)) return SUCCESS;
	else return UNSUCCESS;
}

Status InsertHash(HashTable &H,ElemType e){
	int c = 0;
	int p = 0;
	if(SearchHash(H,e.key,p,c)) return DUPLICATE;
	else if(c<hashsize[H.sizeindex]/2){
		H.elem[p] = e;
		++H.count;
		return OK;
	}else{
		return RecreateHashTable(H,e);
	}
}

int Hash(HashTable H,char* key){
	int length = strlen(key);
	return (key[0]+key[length-1])%hashsize[H.sizeindex];
}

void collision(HashTable H,int &p,int &c){
	p = (p+1)%hashsize[H.sizeindex];
}