哈希查找

const int MaxSize = 50;

typedef int KeyType;

struct SeqList
{
	KeyType key;
	int data;
};

typedef SeqList ElemType;

/*散列（哈希）查找*/

//除留余数法
int Hash(char *k, int m)
{
	int len = strlen(k);
	unsigned int h = 0;
	for(int i = 0; i < len; i++)
	{
		h <<= 3;
		h += k[i];
	}
	return h % m;
}

const int HashMaxSize = 100;

/*开放定址法*/
#ifndef OPENADDRESS

typedef ElemType hashlist1[HashMaxSize];

//初始化
const int NullTag = -1;
const int DeleteTag = 65535;
void InitHashList(hashlist1 HT)
{
	for(int i = 0; i < HashMaxSize; i++)
		HT[i].key = NullTag;  //Nu11Tag常量表示空标志，当关键字
	//类型为字符串时它为空串”\0"，当为数值型时它为一个
	//非关键字的特定数值;另外，对于字符串类型应采用字符
	//串函数进行比较或赋值，下同
}

//清空
void ClearHahList(hashlist1 HT)
{
	for(int i = 0; i < HashMaxSize; i++)
		HT[i].key = NullTag;
}

//插入一个元素
int Insert(hashlist1 HT, int m, ElemType item)
{
	int d = item.key % m; //采用除留余数法
	int temp = d;
	while (HT[d].key != NullTag)
	{
		d = (d + 1) % m;
		if(d == temp)
			return 0;  //查找一周后仍无空位置，返回0表示插入失败
	}
	HT[d] = item;
	return 1;
}

//查找一个元素
int search(hashlist1 HT, int m, ElemType item)
{
	int d = item.key % m; //采用除留余数法
	int temp = d;
	while (HT[d].key != NullTag)
	{
		if(HT[d].key == item.key)
			return d;
		else
			d = (d + 1) % m;
		if(d == temp)
			return -1;
	}
	return -1;
}

//删除一个元素
int Delete(hashlist1 HT, int m, ElemType item)
{
	int d = item.key % m;
	int temp = d;
	while (HT[d].key != NullTag)
	{
		if(HT[d].key == item.key)
		{
			HT[d].key = DeleteTag;
						//DeleteTag常量为一个删除标记，它与关键字具有
						//相同的类型，应为关键字取值范围以外的一个特定值，
						//若不是这样，而是把被删除元素所占用的单元置空，
						//则就割断了元素的查找路径，显然是不行的，该位置
						//可为以后插人元素之用
			return 1;
		}
		else
			d = (d + 1) % m;
		if(d == temp)
			return 0;
	}
	return 0;
}

#endif

/*链接法*/
#ifndef HASHLINKLIST

struct LNode
{
	ElemType data;
	LNode *next;
};

typedef LNode *hashlist2[HashMaxSize];

//初始化
void InitHashList(hashlist2 HT)
{
	for(int i = 0; i < HashMaxSize; i++)
		HT[i] = NULL;
}

//清空，即回收每个单链表中的结点
void ClearHashList(hashlist2 HT)
{
	LNode *p;
	for (int i = 0; i < HashMaxSize; i++)
	{
		p = HT[i];
		while(p != NULL)
		{
			HT[i] = p->next;
			delete p;
			p = HT[i];
		}
	}
}

//插入一个元素
int Insert(hashlist2 HT, int m, ElemType item)
{
	int d = item.key % m;
	LNode *p = new LNode;
	if(p == NULL)
		return 0;
	p->data = item;
	p->next = HT[d];
	HT[d] = p;
	return 1;
}

//查找一个元素
ElemType* search(hashlist2 HT, int m, ElemType item)
{
	int d = item.key % m;;
	LNode *p = HT[d];
	while(p != NULL)
	{
		if(p->data.key == item.key)
			return &(p->data);
		else
			p = p->next;
	}
	return NULL;
}

//删除一个元素
int Delete(hashlist2 HT, int m, ElemType item)
{
	int d = item.key % m;
	LNode *p = HT[d];
	LNode *q;
	if(p == NULL)
		return 0;
	if(p->data.key == item.key)
	{
		HT[d] = p->next;
		delete p;
		return 1;
	}
	q = p->next;
	while(q != NULL)
	{
		if(q->data.key == item.key)
		{
			p->next = q->next;
			delete q;
			return 1;
		}
		else
		{
			p = q;
			q = q->next;
		}
	}
	return 0;
}

#endif