散列函数c语言实现散列函数的应用实例 _hash

C语言中的hash函数Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
HASH主要用于信息安全领域中加密算法，它把一些不同长度的信息转化成杂乱的128位的编码里，叫做HASH值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系。Hash算法在信息安全方面的应用主要体现在以下的3个方面：文件校验、数字签名、鉴权协议
程程序实现
// 说明：Hash函数（即散列函数）在程序设计中的应用目标 ------ 把一个对象通过某种转换机制对应到一个
//size_t类型（即unsigned long）的整型值。
// 而应用Hash函数的领域主要是 hash表（应用非常广）、密码等领域。
// 实现说明：
// ⑴、这里使用了函数对象以及泛型技术，使得对所有类型的对象（关键字）都适用。
// ⑵、常用类型有对应的偏特化，比如string、char*、各种整形等。
// ⑶、版本可扩展，如果你对某种类型有特殊的需要，可以在后面实现专门化。
// ⑷、以下实现一般放在头文件中，任何包含它的都可使用hash函数对象。
//------------------------------------实现------------------------------------------------
#include string
using std::string;
inlinesize_thash_str(const char* s)
{
unsigned long res = 0;
for (; *s;s)
res = 5 * res*s;
returnsize_t(res);
}
template class Key
struct hash
{
size_toperator () (const Key k) const;
};
// 一般的对象，比如：vector queuestring ；的对象，需要强制转化
templateclass Key
size_thashKey::operator () (const Key k) const
{
size_tres = 0;
size_tlen = sizeof(Key);
const char* p = reinterpret_castconst char*(k);
while (len--)
{
res = (res1）^*p;
}
return res;
}
// 偏特化
template
size_thash string ::operator () (const string str) const
{
return hash_str(str.c_str());
}
typedef char* PChar;
【散列函数c语言实现散列函数的应用实例】template
size_thashPChar::operator () (const PChar s) const
{
return hash_str(s);
}
typedef const char* PCChar;
template
size_thashPCChar::operator () (const PCChar s) const
{
return hash_str(s);
}
template size_t hashchar::operator () (const char x) const { return x; }
template size_t hashunsigned char::operator () (const unsigned char x) const { return x; }
template size_t hashsigned char::operator () (const signed char x) const { return x; }
template size_t hashshort::operator () (const short x) const { return x; }
template size_t hashunsigned short::operator () (const unsigned short x) const { return x; }
template size_t hashint::operator () (const int x) const { return x; }
template size_t hashunsigned int::operator () (const unsigned int x) const { return x; }
template size_t hashlong::operator () (const long x) const { return x; }
template size_t hashunsigned long::operator () (const unsigned long x) const { return x; }
// 使用说明：
//
// ⑴、使用时首先由于是泛型，所以要加上关键字类型。
//
// ⑵、其次要有一个函数对象，可以临时、局部、全局的，只要在作用域就可以。
//
// ⑶、应用函数对象作用于对应类型的对象。
//----------------------- hash函数使用举例 -------------------------
#include iostream
#include vector
#include string
using namespace std;
int main()
{
vectorstring vstr⑵；
vstr[0] = "sjw";
vstr[1] = "suninf";
hashstring strhash; // 局部函数对象
cout" Hash value: "strhash(vstr[0])endl;
cout" Hash value: "strhash(vstr[1])endl;
cout" Hash value: "hash vectorstring () (vstr)endl;
cout" Hash value: "hashint() （100）endl; // hashint() 临时函数对象
return 0;
}
散列表的设计c语言实现#include stdio.h
#include string.h
#include stdlib.h
const int HASH_TABLE_SIZE = 13;
typedef struct hash_table_pair_s {
char *key;
int value;
struct hash_table_pair_s *next;
} hash_table_pair_t;
int ELFhash(const char *key)
{
unsigned long h = 0;
unsigned long g;
while( *key )
{
h =( h 4)*key;
g = h0xf0000000L;
if( g ) h ^= g24;
h = ~g;
}
return h;
}
void hash_table_insert(hash_table_pair_t *hash_table, const char *key, int value)
{
int pos;
hash_table_pair_t *new_pair;
char *new_str;
pos = ELFhash(key) % HASH_TABLE_SIZE;
if (hash_table[pos].key != NULL) {
printf("conflict: %s and %s\n", key, hash_table[pos].key);
new_pair = (hash_table_pair_t *)malloc(sizeof(hash_table_pair_t));
new_str = (char *)malloc(sizeof(char) * (strlen(key)1));
strcpy(new_str, key);
new_pair-key = new_str;
new_pair-value = https://www.04ip.com/post/value;
new_pair-next = hash_table[pos].next;
hash_table[pos].next = new_pair;
}
else {
new_str = (char *)malloc(sizeof(char) * (strlen(key)1));
strcpy(new_str, key);
hash_table[pos].key = new_str;
hash_table[pos].value = https://www.04ip.com/post/value;
hash_table[pos].next = NULL;
}
}
int hash_table_get(hash_table_pair_t *hash_table, const char *key, int *value)
{
int pos;
hash_table_pair_t *p;
pos = ELFhash(key) % HASH_TABLE_SIZE;
for (p = hash_table[pos]; p != NULL; p = p-next) {
if (!strcmp(p-key, key)) {
*value = https://www.04ip.com/post/p-value;
return 0;
}
}
return -1;
}
int main()
{
int i, status, value;
const char *MyBirds[13] = { "robin","sparrow","hawk","eagle","seagull","bluejay","owl","cardinal","Jakana","Moa","Egret","Penguin","hawk" };
hash_table_pair_t *hash_table = (hash_table_pair_t *)malloc(HASH_TABLE_SIZE * sizeof(hash_table_pair_t));
for (i = 0; iHASH_TABLE_SIZE; i) {
hash_table[i].key = NULL;
hash_table[i].next = NULL;
hash_table[i].value = https://www.04ip.com/post/0;
}
for (i = 0; isizeof(MyBirds) / sizeof(MyBirds[0]); i) {
hash_table_insert(hash_table, MyBirds[i], i);
}
for (i = 0; isizeof(MyBirds) / sizeof(MyBirds[0]); i) {
status = hash_table_get(hash_table, MyBirds[i], value);
if (status == -1) {
printf("not found %s\n", MyBirds[i]);
}
else {
printf("found %s: %d\n", MyBirds[i], value);
}
}
return 0;
}
C语言运用散列函数拼写检查可以考虑建一个桶式的散列表,表的主体结构是个长为26*27的指针数组,每个指针分别指向一个子链表,每个链表分别存放开头为a,aa,ab,ac......g,ga,gb,......zy,zz为单词.(不区分大小写)
这样的话,假设单词存放在字符串str中,则散列函数就是
h(str)=(str[0]-'A')*27 str[1]-'A'
从题目给的散列函数就可以明显看出,散列表肯定要用长度为HASHSIZE的数组啊,你的链表设想肯定不符合题目要求
设计一个散列函数，用它存储二维点的坐标。这是我们的C语言编程作业，我写了如下代码，但是有BUG：这个已经帮散列函数c语言实现你改了散列函数c语言实现，你可以运行一下
# include stdio.h
# include malloc.h
# include string.h
#define NHASH31
typedef struct zuobiao
{
int x;
int y;
struct zuobiao * next; //chain
}Nameval;
//函数声明
Nameval * create();
Nameval *srt(Nameval *head,Nameval *t);
void main(void)
{
Nameval * sym,*head;
head=create();
//print(head);
sym=(struct zuobiao*)malloc(sizeof(struct zuobiao));
printf("请输入要查找的坐标值散列函数c语言实现：\nx = ");
scanf("%d", sym-x);
printf("y = "); scanf("%d", sym-y);
srt(head,sym);
}
///////////////////////////////////////////////////////////////
Nameval * create()
{
Nameval *head,*tail,*p;int x;
head= tail=NULL;
printf("请输入坐标点的个数散列函数c语言实现：");
scanf("%d",x);
while(x0)
{
p=(struct zuobiao*)malloc(sizeof(struct zuobiao));
printf("请输入坐标的值：\nx = ");
scanf("%d", p-x);
printf("y = "); scanf("%d", p-y);
//p-age=x;
p-next=NULL;
if(head==NULL)
{
head=tail=p;
}
else
{
tail-next=p;
tail=p;
}
x--;
}
return(head);
}
//////////////////////////////////////////////////////////////////
Nameval *srt(Nameval *head,Nameval *t)
{
Nameval *p,*q;
p=(Nameval *)malloc(sizeof(Nameval));
p=head;
if(p==NULL)return NULL;
while(((p-x!=t-x)||(p-y!=t-y))(p-next!=NULL))
{
q=p;
p=p-next;
}
if((p-x==t-x)(p-y==t-y))
{
printf("已经有了这个坐标\n");
}
else if((p-next==NULL)(p-x!=t-x))
{
p-next=t;
t-next=NULL;
printf("新坐标已经插入\n");
}
//free(p);
return head;
}
可以推荐你加QQ群218691837
关于散列函数c语言实现和散列函数的应用实例的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

散列函数c语言实现散列函数的应用实例

推荐阅读

爆炸|手机这样充电比定时炸弹还危险，为了生命安全还是看看吧

东北宜春属于哪个省哪个市宜春属于哪个省哪个市

深度学习|零基础深度学习Pytorch教程，一个小时快速入门（四）

洞庭南馆描写的是哪个季节洞庭南馆是什么季节

骆驼的驼峰有什么用处用英文回答骆驼的驼峰有什么用处

redis几种存储方式 redis以什么方式存储

飞猪订单怎么删除

300M的宽带,用宽带测速显示只相当于20至50M的宽带是怎么回事？

是爸爸大还是叔叔大

格机后关机下电池，再开机系统变成全英文解决办法

遇到松下冰箱显示板怎么拆怎么办？3个处理方法帮助你

皮鞋是摔纹好还是胎牛皮好

林州市哪里林州市新闻

为什么年轮稀疏是南面密是北年轮为什么南疏北密

mysql创建表的sql语句外键 mysql创建表的sql语句

如何判断鲍鱼死了

《自控力》十一

儿童奥司他韦吃几天

北京丰台最低工资标准北京市丰台区低保工资

微信平台直播27级，微信直播等级从0到29级要多少钱

散列函数c语言实现 散列函数的应用实例

推荐阅读

散列函数c语言实现散列函数的应用实例