hashtable-C语言版折叠法+单链表

#include “stdio.h“
#include “hashtable.h“
#include “string.h“
#include “malloc.h“

/*
* 获取哈希表实体
*/
HashTable* hashTable（int size）{

	HashTable* table = calloc（1 sizeof（HashTable））;

	if （!table）{
		return NULL;
	}
	table->size = size;
	table->items = 0;
	table->list = calloc（size sizeof（HashNode））;
	if （!table->list）{
		free（table）;
		return NULL;
	}

	return table;

}

/*
* 哈希表-散列函数
*/
int hashIndex（char* key int size）{
	int segLen = 3;
	int len = strlen（key）;
	int i = 0j = 0k=0;
	long sum = 0;
	while （i < len）{

		if （len - i <= segLen）{
			k = len - i;
		}else{
			k = segLen;
		}

		for （j = 0; j < k; j++）{
			sum += key[i + j] << （8 * （k - j - 1））;
		}

		if （k < segLen）{
			break;
		}

		i += segLen;
	}

	return sum%size;
}

/*
* 哈希表-设置键值
*/
bool hashTable_set（HashTable* table char* key char* value）{
	int index = hashIndex（key table->size）;
	HashNode* node = table->list + index;
	HashNode* tmpNode = NULL;

	if （node->key == NULL || !strcmp（key node->key））{
		tmpNode = node;
	}else{

		while （node->listNext != NULL）{
			node = node->listNext;

			if （!strcmp（key node->key））{
				tmpNode = node;
				break;
			}
		}

		if （!tmpNode）{
			node->listNext = calloc（1 sizeof（HashNode））;
			if （!node->listNext）{ return false; }
			node->listNext->listLast = node;
			tmpNode = node->listNext;
			
		}	

	}

	if （!tmpNode->key）{
		table->items++;
		tmpNode->key = key;
	}

	tmpNode->value = value;

	return true;

}

/*
* 哈希表-获取值
*/
char* hashTable_get（HashTable* table char* key）{
	int index = hashIndex（key table->size）;
	HashNode* node = table->list + index;


	do{
		if （node->key != NULL && !strcmp（key node->key））{
			return node->value;
		}
		node = node->listNext;
	} while （node!= NULL）;

	
	return NULL;
}

/*
* 哈希表-删除健值
*/
bool hasTable_remove（HashTable* table char* key）{
	int index = hashIndex（key table->size）;
	HashNode* node = table->list + index;
	HashNode* tmpNode = NULL;

	do{
		if （node->key != NULL && !strcmp（key node->key））{
			tmpNode = node;
			break;
		}
		node = node->listNext;
	} while （node->listNext != NULL）;

	if （tmpNode）{
		if （!tmpNode->listLast）{
			tmpNode->key = NULL;
			table->items--;
			return true;
		}

		tmpNode->listLast->listNext = tmpNode->listNext;
		if （tmpNode->listNext）{
			tmpNode->listNext->listLast = tmpNode->listLast;
		}
		free（tmpNode）;
		table->items--;
		return true;

	}

	return false;

}

/*
* 遍历哈希表
*/
void hashTable_each（HashTable* table void （*func）（char* keychar* value））{
	int i;
	HashNode* node;

	if （!func || !table->items）{
		return;
	}

	for （i = 0; i < table->size; i++）{
		node = table->list + i;

		do{
			if （node->key != NULL）{
				func（node->key node->value）;
			}
			node = node->listNext;
		} while （node!= NULL）;
		printf（“\n“）;
	}
}

/*
* 哈希表-删除哈希表
*/
void hashTable_delete（HashTable* table）{
	in