随笔 - 169, 文章 - 0, 评论 - 45, 阅读 - 225万

hash算法的意义在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系,(每一个真实值只能有一个键值,但是一个键值可以对应多个真实值),这样可以快速在数组等条件中里面存取数据.　
在网上看了不少HASH资料，所以对HASH的相关资料进行总结和收集。　
　　//HashTable.h template class HashTable{ public :　HashTable( int count ) ;　void put( T* t ,int key ) ;　T* get( int key ) ; private : T** tArray ;　}　
　　//HashTable.cpp template HashTable::HashTable( int count ){　tArray = new T*[count] ;}　template void HashTable::put( T* t , int key ){ this->tArray[ key ] = t ;}template T* HashTable::get( int key )　{　return this->tArray[ key ] ;}　
　　这样,我们只要知道key值,就可以快速存取T类型的数据,而不用像在链表等数据结构中查找一样, 要找来找去的.　至于key值,一般都是用某种算法(所谓的Hash算法)算出来的.例如:字符串的Hash算法, char* value = "hello"; int key = (((((((27* (int)'h'+27)* (int)'e') + 27)　* (int)'l') + 27) * (int)'l' +27) * 27 ) + (int)'o' ;　Hash函数处理流程Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意内容的输入转换成相同长度输出的加密方式.

我来做一个比喻吧。
我们有很多的小猪，每个的体重都不一样，假设体重分布比较平均(我们考虑到公斤级别)，我们按照体重来分,划分成100个小猪圈。
然后把每个小猪，按照体重赶进各自的猪圈里，记录档案。
好了，如果我们要找某个小猪怎么办呢？我们需要每个猪圈，每个小猪的比对吗？
当然不需要了。
我们先看看要找的这个小猪的体重，然后就找到了对应的猪圈了。
在这个猪圈里的小猪的数量就相对很少了。
我们在这个猪圈里就可以相对快的找到我们要找到的那个小猪了。
对应于hash算法。
就是按照hashcode分配不同的猪圈，将hashcode相同的猪放到一个猪圈里。
查找的时候，先找到hashcode对应的猪圈，然后在逐个比较里面的小猪。
所以问题的关键就是建造多少个猪圈比较合适。
如果每个小猪的体重全部不同（考虑到毫克级别)，每个都建一个猪圈，那么我们可以最快速度的找到这头猪。缺点就是，建造那么多猪圈的费用有点太高了。
如果我们按照10公斤级别进行划分，那么建造的猪圈只有几个吧，那么每个圈里的小猪就很多了。我们虽然可以很快的找到猪圈，但从这个猪圈里逐个确定那头小猪也是很累的。
所以，好的hashcode，可以根据实际情况，根据具体的需求，在时间成本(更多的猪圈，更快的速度)和空间本(更少的猪圈，更低的空间需求)之间平衡。

Hash算法有很多很多种类。具体的可以参考之前我写的Hash算法的一些分析。本处给大家提供一个集合了很多使用的Hash算法的类，应该可以满足不少人的需要的：
Java代码

常用的字符串Hash函数还有ELFHash，APHash等等，都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生影响。另外还有以MD5和SHA1为代表的杂凑函数，这些函数几乎不可能找到碰撞。

常用字符串哈希函数有BKDRHash，APHash，DJBHash，JSHash，RSHash，SDBMHash，PJWHash，ELFHash等等。对于以上几种哈希函数，我对其进行了一个小小的评测。



Hash函数数据1 数据2 数据3 数据4 数据1得分数据2得分数据3得分数据4得分平均分
BKDRHash 2 0 4774 481 96.55 100 90.95 82.05 92.64
APHash 2 3 4754 493 96.55 88.46 100 51.28 86.28
DJBHash 2 2 4975 474 96.55 92.31 0 100 83.43
JSHash 1 4 4761 506 100 84.62 96.83 17.95 81.94
RSHash 1 0 4861 505 100 100 51.58 20.51 75.96
SDBMHash 3 2 4849 504 93.1 92.31 57.01 23.08 72.41
PJWHash 30 26 4878 513 0 0 43.89 0 21.95
ELFHash 30 26 4878 513 0 0 43.89 0 21.95


其中数据1为100000个字母和数字组成的随机串哈希冲突个数。数据2为100000个有意义的英文句子哈希冲突个数。数据3为数据1的哈希值与1000003(大素数)求模后存储到线性表中冲突的个数。数据4为数据1的哈希值与10000019(更大素数)求模后存储到线性表中冲突的个数。

经过比较，得出以上平均得分。平均数为平方平均数。可以发现，BKDRHash无论是在实际效果还是编码实现中，效果都是最突出的。APHash也是较为优秀的算法。DJBHash,JSHash,RSHash与SDBMHash各有千秋。PJWHash与ELFHash效果最差，但得分相似，其算法本质是相似的。

在信息修竞赛中，要本着易于编码调试的原则，个人认为BKDRHash是最适合记忆和使用的

C++实现各种hash算法：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

#define M  249997 
#define M1 1000001 
#define M2 0xF0000000 
   
// RS Hash Function  
unsigned int RSHash(char*str) 
{ 
    unsigned int b=378551 ; 
    unsigned int a=63689 ; 
    unsigned int hash=0 ; 
       
    while(*str) 
    { 
        hash=hash*a+(*str++); 
        a*=b ; 
    } 
       
    return(hash % M); 
} 
   
// JS Hash Function  
unsigned int JSHash(char*str) 
{ 
    unsigned int hash=1315423911 ; 
       
    while(*str) 
    { 
        hash^=((hash<<5)+(*str++)+(hash>>2)); 
    } 
       
    return(hash % M); 
} 
   
// P. J. Weinberger Hash Function  
unsigned int PJWHash(char*str) 
{ 
    unsigned int BitsInUnignedInt=(unsigned int)(sizeof(unsigned int)*8); 
    unsigned int ThreeQuarters=(unsigned int)((BitsInUnignedInt*3)/4); 
    unsigned int OneEighth=(unsigned int)(BitsInUnignedInt/8); 
    unsigned int HighBits=(unsigned int)(0xFFFFFFFF)<<(BitsInUnignedInt-OneEighth); 
    unsigned int hash=0 ; 
    unsigned int test=0 ; 
       
    while(*str) 
    { 
        hash=(hash<<OneEighth)+(*str++); 
        if((test=hash&HighBits)!=0) 
        { 
            hash=((hash^(test>>ThreeQuarters))&(~HighBits)); 
        } 
    } 
       
    return(hash % M); 
} 
   
// ELF Hash Function  
unsigned int ELFHash(char*str) 
{ 
    unsigned int hash=0 ; 
    unsigned int x=0 ; 
       
    while(*str) 
    { 
        hash=(hash<<4)+(*str++); 
        if((x=hash&0xF0000000L)!=0) 
        { 
            hash^=(x>>24); 
            hash&=~x ; 
        } 
    } 
       
    return(hash % M); 
} 
   
// BKDR Hash Function  
unsigned int BKDRHash(char*str) 
{ 
    unsigned int seed=131 ;// 31 131 1313 13131 131313 etc..  
    unsigned int hash=0 ; 
       
    while(*str) 
    { 
        hash=hash*seed+(*str++); 
    } 
       
    return(hash % M); 
} 
   
// SDBM Hash Function  
unsigned int SDBMHash(char*str) 
{ 
    unsigned int hash=0 ; 
       
    while(*str) 
    { 
        hash=(*str++)+(hash<<6)+(hash<<16)-hash ; 
    } 
       
    return(hash % M); 
} 
   
// DJB Hash Function  
unsigned int DJBHash(char*str) 
{ 
    unsigned int hash=5381 ; 
       
    while(*str) 
    { 
        hash+=(hash<<5)+(*str++); 
    } 
       
    return(hash % M); 
} 
   
// AP Hash Function  
unsigned int APHash(char*str) 
{ 
    unsigned int hash=0 ; 
    int i ; 
       
    for(i=0;*str;i++) 
    { 
        if((i&1)==0) 
        { 
            hash^=((hash<<7)^(*str++)^(hash>>3)); 
        } 
        else
        { 
            hash^=(~((hash<<11)^(*str++)^(hash>>5))); 
        } 
    } 
       
    return(hash % M); 
} 
   
  
  
/**   
* Hash算法大全<br>   
* 推荐使用FNV1算法   
* @algorithm None   
* @author Goodzzp 2006-11-20   
* @lastEdit Goodzzp 2006-11-20    
* @editDetail Create   
*/ 
public class HashAlgorithms    
{    
/**   
* 加法hash   
* @param key 字符串   
* @param prime 一个质数   
* @return hash结果   
*/ 
public static int additiveHash(String key, int prime)    
{    
   int hash, i;    
   for (hash = key.length(), i = 0; i < key.length(); i++)    
    hash += key.charAt(i);    
   return (hash % prime);    
}    
     
/**   
* 旋转hash   
* @param key 输入字符串   
* @param prime 质数   
* @return hash值   
*/ 
public static int rotatingHash(String key, int prime)    
{    
   int hash, i;    
   for (hash=key.length(), i=0; i<key.length(); ++i)    
     hash = (hash<<4)^(hash>>28)^key.charAt(i);    
   return (hash % prime);    
//   return (hash ^ (hash>>10) ^ (hash>>20));    
}    
     
// 替代：    
// 使用：hash = (hash ^ (hash>>10) ^ (hash>>20)) & mask;    
// 替代：hash %= prime;    
     
     
/**   
* MASK值，随便找一个值，最好是质数   
*/ 
static int M_MASK = 0x8765fed1;    
/**   
* 一次一个hash   
* @param key 输入字符串   
* @return 输出hash值   
*/ 
public static int oneByOneHash(String key)    
{    
   int   hash, i;    
   for (hash=0, i=0; i<key.length(); ++i)    
   {    
     hash += key.charAt(i);    
     hash += (hash << 10);    
     hash ^= (hash >> 6);    
   }    
   hash += (hash << 3);    
   hash ^= (hash >> 11);    
   hash += (hash << 15);    
//   return (hash & M_MASK);    
   return hash;    
}    
     
/**   
* Bernstein's hash   
* @param key 输入字节数组   
* @param level 初始hash常量   
* @return 结果hash   
*/ 
public static int bernstein(String key)    
{    
   int hash = 0;    
   int i;    
   for (i=0; i<key.length(); ++i) hash = 33*hash + key.charAt(i);    
   return hash;    
}    
     
//    
//// Pearson's Hash    
// char pearson(char[]key, ub4 len, char tab[256])    
// {    
//   char hash;    
//   ub4 i;    
//   for (hash=len, i=0; i<len; ++i)     
//     hash=tab[hash^key[i]];    
//   return (hash);    
// }    
     
//// CRC Hashing，计算crc,具体代码见其他    
// ub4 crc(char *key, ub4 len, ub4 mask, ub4 tab[256])    
// {    
//   ub4 hash, i;    
//   for (hash=len, i=0; i<len; ++i)    
//     hash = (hash >> 8) ^ tab[(hash & 0xff) ^ key[i]];    
//   return (hash & mask);    
// }    
     
/**   
* Universal Hashing   
*/ 
public static int universal(char[]key, int mask, int[] tab)    
{    
   int hash = key.length, i, len = key.length;    
   for (i=0; i<(len<<3); i+=8)    
   {    
     char k = key[i>>3];    
     if ((k&0x01) == 0) hash ^= tab[i+0];    
     if ((k&0x02) == 0) hash ^= tab[i+1];    
     if ((k&0x04) == 0) hash ^= tab[i+2];    
     if ((k&0x08) == 0) hash ^= tab[i+3];    
     if ((k&0x10) == 0) hash ^= tab[i+4];    
     if ((k&0x20) == 0) hash ^= tab[i+5];    
     if ((k&0x40) == 0) hash ^= tab[i+6];    
     if ((k&0x80) == 0) hash ^= tab[i+7];    
   }    
   return (hash & mask);    
}    
     
/**   
* Zobrist Hashing   
*/   
public static int zobrist( char[] key,int mask, int[][] tab)    
{    
   int hash, i;    
   for (hash=key.length, i=0; i<key.length; ++i)    
     hash ^= tab[i][key[i]];    
   return (hash & mask);    
}    
     
// LOOKUP3     
// 见Bob Jenkins(3).c文件    
     
// 32位FNV算法    
static int M_SHIFT = 0;    
/**   
* 32位的FNV算法   
* @param data 数组   
* @return int值   
*/ 
    public static int FNVHash(byte[] data)    
    {    
        int hash = (int)2166136261L;    
        for(byte b : data)    
            hash = (hash * 16777619) ^ b;    
        if (M_SHIFT == 0)    
            return hash;    
        return (hash ^ (hash >> M_SHIFT)) & M_MASK;    
    }    
    /**   
     * 改进的32位FNV算法1   
     * @param data 数组   
     * @return int值   
     */ 
    public static int FNVHash1(byte[] data)    
    {    
        final int p = 16777619;    
        int hash = (int)2166136261L;    
        for(byte b:data)    
            hash = (hash ^ b) * p;    
        hash += hash << 13;    
        hash ^= hash >> 7;    
        hash += hash << 3;    
        hash ^= hash >> 17;    
        hash += hash << 5;    
        return hash;    
    }    
    /**   
     * 改进的32位FNV算法1   
     * @param data 字符串   
     * @return int值   
     */ 
    public static int FNVHash1(String data)    
    {    
        final int p = 16777619;    
        int hash = (int)2166136261L;    
        for(int i=0;i<data.length();i++)    
            hash = (hash ^ data.charAt(i)) * p;    
        hash += hash << 13;    
        hash ^= hash >> 7;    
        hash += hash << 3;    
        hash ^= hash >> 17;    
        hash += hash << 5;    
        return hash;    
    }    
     
    /**   
     * Thomas Wang的算法，整数hash   
     */   
    public static int intHash(int key)    
    {    
      key += ~(key << 15);    
      key ^= (key >>> 10);    
      key += (key << 3);    
      key ^= (key >>> 6);    
      key += ~(key << 11);    
      key ^= (key >>> 16);    
      return key;    
    }    
    /**   
     * RS算法hash   
     * @param str 字符串   
     */ 
    public static int RSHash(String str)    
    {    
        int b    = 378551;    
        int a    = 63689;    
        int hash = 0;    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash = hash * a + str.charAt(i);    
          a    = a * b;    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of RS Hash Function */ 
     
    /**   
     * JS算法   
     */ 
    public static int JSHash(String str)    
    {    
       int hash = 1315423911;    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash ^= ((hash << 5) + str.charAt(i) + (hash >> 2));    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of JS Hash Function */ 
     
    /**   
     * PJW算法   
     */ 
    public static int PJWHash(String str)    
    {    
        int BitsInUnsignedInt = 32;    
        int ThreeQuarters     = (BitsInUnsignedInt * 3) / 4;    
        int OneEighth         = BitsInUnsignedInt / 8;    
        int HighBits          = 0xFFFFFFFF << (BitsInUnsignedInt - OneEighth);    
        int hash              = 0;    
        int test              = 0;    
     
       for(int i = 0; i < str.length();i++)    
       {    
          hash = (hash << OneEighth) + str.charAt(i);    
     
          if((test = hash & HighBits) != 0)    
          {    
             hash = (( hash ^ (test >> ThreeQuarters)) & (~HighBits));    
          }    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of P. J. Weinberger Hash Function */ 
     
    /**   
     * ELF算法   
     */ 
    public static int ELFHash(String str)    
    {    
        int hash = 0;    
        int x    = 0;    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash = (hash << 4) + str.charAt(i);    
          if((x = (int)(hash & 0xF0000000L)) != 0)    
          {    
             hash ^= (x >> 24);    
             hash &= ~x;    
          }    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of ELF Hash Function */ 
     
    /**   
     * BKDR算法   
     */ 
    public static int BKDRHash(String str)    
    {    
        int seed = 131; // 31 131 1313 13131 131313 etc..    
        int hash = 0;    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash = (hash * seed) + str.charAt(i);    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of BKDR Hash Function */ 
     
    /**   
     * SDBM算法   
     */ 
    public static int SDBMHash(String str)    
    {    
        int hash = 0;    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash = str.charAt(i) + (hash << 6) + (hash << 16) - hash;    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of SDBM Hash Function */ 
     
    /**   
     * DJB算法   
     */ 
    public static int DJBHash(String str)    
    {    
       int hash = 5381;    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash = ((hash << 5) + hash) + str.charAt(i);    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of DJB Hash Function */ 
     
    /**   
     * DEK算法   
     */ 
    public static int DEKHash(String str)    
    {    
        int hash = str.length();    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash = ((hash << 5) ^ (hash >> 27)) ^ str.charAt(i);    
       }    
     
       return (hash & 0x7FFFFFFF);    
    }    
    /* End Of DEK Hash Function */ 
     
    /**   
     * AP算法   
     */ 
    public static int APHash(String str)    
    {    
        int hash = 0;    
     
       for(int i = 0; i < str.length(); i++)    
       {    
          hash ^= ((i & 1) == 0) ? ( (hash << 7) ^ str.charAt(i) ^ (hash >> 3)) :    
                                   (~((hash << 11) ^ str.charAt(i) ^ (hash >> 5)));    
       }    
     
//       return (hash & 0x7FFFFFFF);    
       return hash;    
    }    
    /* End Of AP Hash Function */ 
          
    /**   
     * JAVA自己带的算法   
     */ 
    public static int java(String str)    
{    
   int h = 0;    
   int off = 0;    
   int len = str.length();    
   for (int i = 0; i < len; i++)    
   {    
    h = 31 * h + str.charAt(off++);    
   }    
   return h;    
}    
          
    /**   
     * 混合hash算法，输出64位的值   
     */ 
      public static long mixHash(String str)    
     {    
    long hash = str.hashCode();    
     hash <<= 32;    
     hash |= FNVHash1(str);    
    return hash;    
     }