C語言編程，求字符串的hash值（散列值）

#includestdio.h

創新互聯主要從事網站制作、做網站、網頁設計、企業做網站、公司建網站等業務。立足成都服務東臺,10余年網站建設經驗,價格優惠、服務專業,歡迎來電咨詢建站服務:13518219792

int?main(){

char?s[256];

char?*p;

unsigned?long?long?int?h?=?0;

scanf("%s",?s);

for(p=s;?*p;?p++){

h?=?h*31?+?*p;

}

printf("%llu",?h);

}

c語言hash函數有幾種

#include?stdio.h#include?stdlib.h//這里我自己設計一個hash算法來快速查找一堆數字中相等的數字，這也許是最接近原理的算法了//一個整數整除27后的來作為hash函數//定義一個保存實際數據的結構體節點struct?data_node{????int?num;????int?count;????struct?data_node?*next;};//定義一個結構體時hash表的一部分typedef?struct{????int?key;?//余數????struct?data_node?*p;?//鏈表的頭指針}?hash_node;#define?HASH_SIZE?27int?do_hash(int?num)?//hash表來求余數，這樣就可以了{????return?num%HASH_SIZE;}//初始化//添加數字//更新數字//刪除數字//查找數字hash_node?HashTable[HASH_SIZE];?//這里申明一個hashtable的數組//初始化函數，需要做的事將key復制為null，將p指針指向null,返回一個頭指針來指向這個hashtablevoid?InitHashTable(hash_node?*HashTable)

{????//進行參數的校驗????for(int?i=0;iHASH_SIZE;i++)

{

HashTable[i].key?=?0;????????HashTable[i].p?=NULL;????}

}//保存到這個鏈表中//如果這個鏈表是空的話，就作為頭指針，如果這個鏈表不為空，則添加到吧數字添加到末尾int?savedata(struct?data_node?**head,int?num)

{????struct?data_node?*tmp_p?=?*head;????struct?data_node?*p?=?(struct?data_node?*)malloc(sizeof(struct?data_node));????if(p?==?NULL)????????return?0;????if(*head?==?NULL)

{

*head?=?p;????????p-count?=?1;????????p-num?=?num;????????p-next?=?NULL;????}????else?//如果不為空，則這個時候應該添加到鏈表末尾????{????????while(tmp_p?!=?NULL)//如果存在，則將這個節點的count加1就可以了????????{????????????if(tmp_p-num?==?num)

{

free(p);????????????????++tmp_p-count?;????????????????return?0;????????????}????????????if(tmp_p-next?==?NULL)????????????????break;????????????tmp_p?=?tmp_p-next;????????}

tmp_p-next?=?p;????????p-count?=1;????????p-num?=?num;????????p-next?=?NULL;????}????return?0;}//添加數字//將這個數字經過hash求出結果，然后再保存到相應的鏈表中//返回真或者假就可以了int?add_hash(hash_node?*HashTable,int?num)

{????int?mod?=?do_hash(num);????return?savedata(HashTable[mod].p,num);}int?main()

{????int?num?=?100;????hash_node?*H?=?HashTable;????InitHashTable(H);????add_hash(H,num);????add_hash(H,num);????add_hash(H,3);????add_hash(H,1);????add_hash(H,4);????//在這里我們可以發現一個好的hash函數是多么的重要，如果hash函數不好造成很多沖突的話，效率并不會提高很多的，理想的情況是沖突幾乎沒有????//這也就是設計hash函數的精髓所在????return?0;}

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 ；的對象，需要強制轉化

template class 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;

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語言獲取文件的SHA1哈希值

有現成的SHA1算法函數

復制過來。

然后打開文件， 讀數據， 調用SHA1函數即可。

#include?stdio.h

#include?stdlib.h

#include?string.h

#include?assert.h

#include?errno.h

#undef?BIG_ENDIAN_HOST

typedef?unsigned?int?u32;

/****************

*?Rotate?a?32?bit?integer?by?n?bytes

*/

#if?defined(__GNUC__)??defined(__i386__)

static?inline?u32

rol(?u32?x,?int?n)

{

__asm__("roll?%%cl,%0"

:"=r"?(x)

:"0"?(x),"c"?(n));

return?x;

}

#else

#define?rol(x,n)?(?((x)??(n))?|?((x)??(32-(n)))?)

#endif

typedef?struct?{

u32??h0,h1,h2,h3,h4;

u32??nblocks;

unsigned?char?buf[64];

int??count;

}?SHA1_CONTEXT;

void

sha1_init(?SHA1_CONTEXT?*hd?)

{

hd-h0?=?0x67452301;

hd-h1?=?0xefcdab89;

hd-h2?=?0x98badcfe;

hd-h3?=?0x10325476;

hd-h4?=?0xc3d2e1f0;

hd-nblocks?=?0;

hd-count?=?0;

}

/****************

*?Transform?the?message?X?which?consists?of?16?32-bit-words

*/

static?void

transform(?SHA1_CONTEXT?*hd,?unsigned?char?*data?)

{

u32?a,b,c,d,e,tm;

u32?x[16];

/*?get?values?from?the?chaining?vars?*/

a?=?hd-h0;

b?=?hd-h1;

c?=?hd-h2;

d?=?hd-h3;

e?=?hd-h4;

#ifdef?BIG_ENDIAN_HOST

memcpy(?x,?data,?64?);

#else

{

int?i;

unsigned?char?*p2;

for(i=0,?p2=(unsigned?char*)x;?i??16;?i++,?p2?+=?4?)?

{

p2[3]?=?*data++;

p2[2]?=?*data++;

p2[1]?=?*data++;

p2[0]?=?*data++;

}

}

#endif

#define?K1??0x5A827999L

#define?K2??0x6ED9EBA1L

#define?K3??0x8F1BBCDCL

#define?K4??0xCA62C1D6L

#define?F1(x,y,z)???(?z?^?(?x??(?y?^?z?)?)?)

#define?F2(x,y,z)???(?x?^?y?^?z?)

#define?F3(x,y,z)???(?(?x??y?)?|?(?z??(?x?|?y?)?)?)

#define?F4(x,y,z)???(?x?^?y?^?z?)

#define?M(i)?(?tm?=???x[i0x0f]?^?x[(i-14)0x0f]?\

^?x[(i-8)0x0f]?^?x[(i-3)0x0f]?\

,?(x[i0x0f]?=?rol(tm,1))?)

#define?R(a,b,c,d,e,f,k,m)??do?{?e?+=?rol(?a,?5?)?????\

+?f(?b,?c,?d?)??\

+?k ??????\

+?m; ??????\

b?=?rol(?b,?30?);????\

}?while(0)

R(?a,?b,?c,?d,?e,?F1,?K1,?x[?0]?);

R(?e,?a,?b,?c,?d,?F1,?K1,?x[?1]?);

R(?d,?e,?a,?b,?c,?F1,?K1,?x[?2]?);

R(?c,?d,?e,?a,?b,?F1,?K1,?x[?3]?);

R(?b,?c,?d,?e,?a,?F1,?K1,?x[?4]?);

R(?a,?b,?c,?d,?e,?F1,?K1,?x[?5]?);

R(?e,?a,?b,?c,?d,?F1,?K1,?x[?6]?);

R(?d,?e,?a,?b,?c,?F1,?K1,?x[?7]?);

R(?c,?d,?e,?a,?b,?F1,?K1,?x[?8]?);

R(?b,?c,?d,?e,?a,?F1,?K1,?x[?9]?);

R(?a,?b,?c,?d,?e,?F1,?K1,?x[10]?);

R(?e,?a,?b,?c,?d,?F1,?K1,?x[11]?);

R(?d,?e,?a,?b,?c,?F1,?K1,?x[12]?);

R(?c,?d,?e,?a,?b,?F1,?K1,?x[13]?);

R(?b,?c,?d,?e,?a,?F1,?K1,?x[14]?);

R(?a,?b,?c,?d,?e,?F1,?K1,?x[15]?);

R(?e,?a,?b,?c,?d,?F1,?K1,?M(16)?);

R(?d,?e,?a,?b,?c,?F1,?K1,?M(17)?);

R(?c,?d,?e,?a,?b,?F1,?K1,?M(18)?);

R(?b,?c,?d,?e,?a,?F1,?K1,?M(19)?);

R(?a,?b,?c,?d,?e,?F2,?K2,?M(20)?);

R(?e,?a,?b,?c,?d,?F2,?K2,?M(21)?);

R(?d,?e,?a,?b,?c,?F2,?K2,?M(22)?);

R(?c,?d,?e,?a,?b,?F2,?K2,?M(23)?);

R(?b,?c,?d,?e,?a,?F2,?K2,?M(24)?);

R(?a,?b,?c,?d,?e,?F2,?K2,?M(25)?);

R(?e,?a,?b,?c,?d,?F2,?K2,?M(26)?);

R(?d,?e,?a,?b,?c,?F2,?K2,?M(27)?);

R(?c,?d,?e,?a,?b,?F2,?K2,?M(28)?);

R(?b,?c,?d,?e,?a,?F2,?K2,?M(29)?);

R(?a,?b,?c,?d,?e,?F2,?K2,?M(30)?);

R(?e,?a,?b,?c,?d,?F2,?K2,?M(31)?);

R(?d,?e,?a,?b,?c,?F2,?K2,?M(32)?);

R(?c,?d,?e,?a,?b,?F2,?K2,?M(33)?);

R(?b,?c,?d,?e,?a,?F2,?K2,?M(34)?);

R(?a,?b,?c,?d,?e,?F2,?K2,?M(35)?);

R(?e,?a,?b,?c,?d,?F2,?K2,?M(36)?);

R(?d,?e,?a,?b,?c,?F2,?K2,?M(37)?);

R(?c,?d,?e,?a,?b,?F2,?K2,?M(38)?);

R(?b,?c,?d,?e,?a,?F2,?K2,?M(39)?);

R(?a,?b,?c,?d,?e,?F3,?K3,?M(40)?);

R(?e,?a,?b,?c,?d,?F3,?K3,?M(41)?);

R(?d,?e,?a,?b,?c,?F3,?K3,?M(42)?);

R(?c,?d,?e,?a,?b,?F3,?K3,?M(43)?);

R(?b,?c,?d,?e,?a,?F3,?K3,?M(44)?);

R(?a,?b,?c,?d,?e,?F3,?K3,?M(45)?);

R(?e,?a,?b,?c,?d,?F3,?K3,?M(46)?);

R(?d,?e,?a,?b,?c,?F3,?K3,?M(47)?);

R(?c,?d,?e,?a,?b,?F3,?K3,?M(48)?);

R(?b,?c,?d,?e,?a,?F3,?K3,?M(49)?);

R(?a,?b,?c,?d,?e,?F3,?K3,?M(50)?);

R(?e,?a,?b,?c,?d,?F3,?K3,?M(51)?);

R(?d,?e,?a,?b,?c,?F3,?K3,?M(52)?);

R(?c,?d,?e,?a,?b,?F3,?K3,?M(53)?);

R(?b,?c,?d,?e,?a,?F3,?K3,?M(54)?);

R(?a,?b,?c,?d,?e,?F3,?K3,?M(55)?);

R(?e,?a,?b,?c,?d,?F3,?K3,?M(56)?);

R(?d,?e,?a,?b,?c,?F3,?K3,?M(57)?);

R(?c,?d,?e,?a,?b,?F3,?K3,?M(58)?);

R(?b,?c,?d,?e,?a,?F3,?K3,?M(59)?);

R(?a,?b,?c,?d,?e,?F4,?K4,?M(60)?);

R(?e,?a,?b,?c,?d,?F4,?K4,?M(61)?);

R(?d,?e,?a,?b,?c,?F4,?K4,?M(62)?);

R(?c,?d,?e,?a,?b,?F4,?K4,?M(63)?);

R(?b,?c,?d,?e,?a,?F4,?K4,?M(64)?);

R(?a,?b,?c,?d,?e,?F4,?K4,?M(65)?);

R(?e,?a,?b,?c,?d,?F4,?K4,?M(66)?);

R(?d,?e,?a,?b,?c,?F4,?K4,?M(67)?);

R(?c,?d,?e,?a,?b,?F4,?K4,?M(68)?);

R(?b,?c,?d,?e,?a,?F4,?K4,?M(69)?);

R(?a,?b,?c,?d,?e,?F4,?K4,?M(70)?);

R(?e,?a,?b,?c,?d,?F4,?K4,?M(71)?);

R(?d,?e,?a,?b,?c,?F4,?K4,?M(72)?);

R(?c,?d,?e,?a,?b,?F4,?K4,?M(73)?);

R(?b,?c,?d,?e,?a,?F4,?K4,?M(74)?);

R(?a,?b,?c,?d,?e,?F4,?K4,?M(75)?);

R(?e,?a,?b,?c,?d,?F4,?K4,?M(76)?);

R(?d,?e,?a,?b,?c,?F4,?K4,?M(77)?);

R(?c,?d,?e,?a,?b,?F4,?K4,?M(78)?);

R(?b,?c,?d,?e,?a,?F4,?K4,?M(79)?);

/*?Update?chaining?vars?*/

hd-h0?+=?a;

hd-h1?+=?b;

hd-h2?+=?c;

hd-h3?+=?d;

hd-h4?+=?e;

}

/*?Update?the?message?digest?with?the?contents

*?of?INBUF?with?length?INLEN.

*/

static?void

sha1_write(?SHA1_CONTEXT?*hd,?unsigned?char?*inbuf,?size_t?inlen)

{

if(?hd-count?==?64?)?{?/*?flush?the?buffer?*/

transform(?hd,?hd-buf?);

hd-count?=?0;

hd-nblocks++;

}

if(?!inbuf?)

return;

if(?hd-count?)?{

for(?;?inlen??hd-count??64;?inlen--?)

hd-buf[hd-count++]?=?*inbuf++;

sha1_write(?hd,?NULL,?0?);

if(?!inlen?)

return;

}

while(?inlen?=?64?)?{

transform(?hd,?inbuf?);

hd-count?=?0;

hd-nblocks++;

inlen?-=?64;

inbuf?+=?64;

}

for(?;?inlen??hd-count??64;?inlen--?)

hd-buf[hd-count++]?=?*inbuf++;

}

/*?The?routine?final?terminates?the?computation?and

*?returns?the?digest.

*?The?handle?is?prepared?for?a?new?cycle,?but?adding?bytes?to?the

*?handle?will?the?destroy?the?returned?buffer.

*?Returns:?20?bytes?representing?the?digest.

*/

static?void

sha1_final(SHA1_CONTEXT?*hd)

{

u32?t,?msb,?lsb;

unsigned?char?*p;

sha1_write(hd,?NULL,?0);?/*?flush?*/;

t?=?hd-nblocks;

/*?multiply?by?64?to?make?a?byte?count?*/

lsb?=?t??6;

msb?=?t??26;

/*?add?the?count?*/

t?=?lsb;

if(?(lsb?+=?hd-count)??t?)

msb++;

/*?multiply?by?8?to?make?a?bit?count?*/

t?=?lsb;

lsb?=?3;

msb?=?3;

msb?|=?t??29;

if(?hd-count??56?)?{?/*?enough?room?*/

hd-buf[hd-count++]?=?0x80;?/*?pad?*/

while(?hd-count??56?)

hd-buf[hd-count++]?=?0;??/*?pad?*/

}

else?{?/*?need?one?extra?block?*/

hd-buf[hd-count++]?=?0x80;?/*?pad?character?*/

while(?hd-count??64?)

hd-buf[hd-count++]?=?0;

sha1_write(hd,?NULL,?0);??/*?flush?*/;

memset(hd-buf,?0,?56?);?/*?fill?next?block?with?zeroes?*/

}

/*?append?the?64?bit?count?*/

hd-buf[56]?=?msb??24;

hd-buf[57]?=?msb??16;

hd-buf[58]?=?msb???8;

hd-buf[59]?=?msb ???;

hd-buf[60]?=?lsb??24;

hd-buf[61]?=?lsb??16;

hd-buf[62]?=?lsb???8;

hd-buf[63]?=?lsb ???;

transform(?hd,?hd-buf?);

p?=?hd-buf;

#ifdef?BIG_ENDIAN_HOST

#define?X(a)?do?{?*(u32*)p?=?hd-h##a?;?p?+=?4;?}?while(0)

#else?/*?little?endian?*/

#define?X(a)?do?{?*p++?=?hd-h##a??24;?*p++?=?hd-h##a??16; ?\

*p++?=?hd-h##a??8;?*p++?=?hd-h##a;?}?while(0)

#endif

X(0);

X(1);

X(2);

X(3);

X(4);

#undef?X

}

C語言哈希表

/#include "iostream.h"

#include iostream

#include "string.h"

#include "fstream"

#define NULL 0

unsigned int key;

unsigned int key2;

int *p;

struct node //建節點

{

char name[8],address[20];

char num[11];

node * next;

};

typedef node* pnode;

typedef node* mingzi;

node **phone;

node **nam;

node *a;

using namespace std; //使用名稱空間

void hash(char num[11]) //哈希函數

{

int i = 3;

key=(int)num[2];

while(num[i]!=NULL)

{

key+=(int)num[i];

i++;

}

key=key%20;

}

void hash2(char name[8]) //哈希函數

{

int i = 1;

key2=(int)name[0];

while(name[i]!=NULL)

{

key2+=(int)name[i];

i++;

}

key2=key2%20;

}

node* input() //輸入節點

{

node *temp;

temp = new node;

temp-next=NULL;

cout"輸入姓名："endl;

cintemp-name;

cout"輸入地址："endl;

cintemp-address;

cout"輸入電話："endl;

cintemp-num;

return temp;

}

int apend() //添加節點

{

node *newphone;

node *newname;

newphone=input();

newname=newphone;

newphone-next=NULL;

newname-next=NULL;

hash(newphone-num);

hash2(newname-name);

newphone-next = phone[key]-next;

phone[key]-next=newphone;

newname-next = nam[key2]-next;

nam[key2]-next=newname;

return 0;

}

void create() //新建節點

{

int i;

phone=new pnode[20];

for(i=0;i20;i++)

{

phone[i]=new node;

phone[i]-next=NULL;

}

}

void create2() //新建節點

{

int i;

nam=new mingzi[20];

for(i=0;i20;i++)

{

nam[i]=new node;

nam[i]-next=NULL;

}

}

void list() //顯示列表

{

int i;

node *p;

for(i=0;i20;i++)

{

p=phone[i]-next;

while(p)

{

coutp-name'_'p-address'_'p-numendl;

p=p-next;

}

}

}

void list2() //顯示列表

{

int i;

node *p;

for(i=0;i20;i++)

{

p=nam[i]-next;

while(p)

{

coutp-name'_'p-address'_'p-numendl;

p=p-next;

}

}

}

void find(char num[11]) //查找用戶信息

{

hash(num);

node *q=phone[key]-next;

while(q!= NULL)

{

if(strcmp(num,q-num)==0)

break;

q=q-next;

}

if(q)

coutq-name"_" q-address"_"q-numendl;

else cout"無此記錄"endl;

}

void find2(char name[8]) //查找用戶信息

{

hash2(name);

node *q=nam[key2]-next;

while(q!= NULL)

{

if(strcmp(name,q-name)==0)

break;

q=q-next;

}

if(q)

coutq-name"_" q-address"_"q-numendl;

else cout"無此記錄"endl;

}

void save() //保存用戶信息

{

int i;

node *p;

for(i=0;i20;i++)

{

p=phone[i]-next;

while(p)

{

fstream iiout("out.txt", ios::out);

iioutp-name"_"p-address"_"p-numendl;

p=p-next;

}

}

}

void menu() //菜單

{

cout"0.添加記錄"endl;

cout"3.查找記錄"endl;

cout"2.姓名散列"endl;

cout"4.號碼散列"endl;

cout"5.清空記錄"endl;

cout"6.保存記錄"endl;

cout"7.退出系統"endl;

}

int main()

{

char num[11];

char name[8];

create();

create2() ;

int sel;

while(1)

{

menu();

cinsel;

if(sel==3)

{ cout"9號碼查詢，8姓名查詢"endl;

int b;

cinb;

if(b==9)

{ cout"請輸入電話號碼:"endl;

cin num;

cout"輸出查找的信息:"endl;

find(num);

}

else

{ cout"請輸入姓名:"endl;

cin name;

cout"輸出查找的信息:"endl;

find2(name);}

}

if(sel==2)

{ cout"姓名散列結果:"endl;

list2();

}

if(sel==0)

{ cout"請輸入要添加的內容:"endl;

apend();

}

if(sel==4)

{ cout"號碼散列結果:"endl;

list();

}

if(sel==5)

{ cout"列表已清空:"endl;

create();

create2();

}

if(sel==6)

{ cout"通信錄已保存:"endl;

save();

}

if(sel==7) return 0;

}

return 0;

}

C語言實現哈希表的相關運算算法 編寫程序實現哈希表的構造過程。

#define MaxSize 100 //定義最大哈希表長度

#define NULLKEY -1 //定義空關鍵字值

#define DELKEY -2 //定義被刪關鍵字值

typedef int KeyType; //關鍵字類型

typedef char * InfoType; //其他數據類型

typedef struct

{

KeyType key; //關鍵字域

InfoType data; //其他數據域

int count; //探查次數域

} HashData;

typedef HashData HashTable[MaxSize]; //哈希表類型

void InsertHT(HashTable ha,int n,KeyType k,int p) //將關鍵字k插入到哈希表中

{

int i,adr;

adr=k % p;

if (ha[adr].key==NULLKEY || ha[adr].key==DELKEY) //x[j]可以直接放在哈希表中

{

ha[adr].key=k;

ha[adr].count=1;

}

else //發生沖突時采用線性探查法解決沖突

{

i=1; //i記錄x[j]發生沖突的次數

do

{

adr=(adr+1) % p;

i++;

}

while (ha[adr].key!=NULLKEY ha[adr].key!=DELKEY);

ha[adr].key=k;

ha[adr].count=i;

}

n++;

}

void CreateHT(HashTable ha,KeyType x[],int n,