1.什么是哈希表？
哈希表是一种数据结构，它可以提供快速的插入和删除操作。如果存储在哈希表中的数据较好的满足了哈希表的要求，那么在哈希表中执行插入和操作只需要接近常量的时间，即时间复杂度为o（1），但哈希表也不是十全十美的，它也存在着缺点，这都会在下面慢慢谈到.
2.哈希表的存储方式
哈希表是通过数组来存储数据的，但数据并不是直接放入数组中（直接放入就是数组存储啦！）。说到这里就需要谈到哈希化，而哈希表的核心部分，我认为就是哈希化了：简而言之，将数据插入哈希表中的数组的相应位置的规则，就是哈希化，再简单来说，就是将数据通过某种方法（即哈希函数，可以自己定义）转化得到一个数据下标（这就是这个数据应该存储的位置），将该数据放入到该下标对应的数组位置中，使用哈希函数向数组中插入数据，得到的就是一个哈希表。这里来用一个简单的示例来向大家介绍哈希表：
如果我们需要存储5个数据：5 、 31、 58 、75 、87 存储在容量为10的哈希表中。
1.首先，我们需要定义一个哈希函数，我这里的定义的哈希函数为 arrayIndex = Number % arraySize；这里arrayIndex就对应着要插入的数组坐标位置；
2.计算数组下标，上面的数据计算结果为：5， 1， 8，5，7
3.向数组中插入数据，得到哈希表
|
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
|
31 |
5 |
75 |
87 |
58 |
这样子来看，是不是简单的！但事实上对于这几个数据来说确实挺简单的。但是这里我们还有很多东西没有去讨论，大家继续向下看：
大家注意到没有，5和75得到的数组下标都是5，它们产生了冲突，那它怎么插入到数组中的呢？对于这种情况有很多中方式处理，这里用的是开放地址法的线性探测方法。
这里就介绍这几中解决这种冲突的方法
3.冲突解决
这里解决的方法主要有两种：开放地址法和链地址法
一、开放地址法
开放地址法包括三种方法：线性探测（上面用到的）、二次探测、再哈希法。
1.线性探测
在线性探测的方法中，当冲突产生时会线性的查找空白单元。正如上面所提到的，当插入75时，因为当前数组下标为5的位置被数据 5 所占据，因此数组下标就会继续向下查找，此时下标为5的数组位置是空闲的，数据75就插入其中；如果此时我们再插入一个元素45，开始查询数组下标位置为5的数组位置，不为空---》查询数组下标为6：不为空---》查询数组下标为7：不为空---》查询数组下标为8：不为空---》查询数组下标为9：为空---》在数组下标为9的位置插入45.
|
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
|
31 |
5 |
75 |
87 |
58 |
45 |
哈希表中，一连串的已填充单元叫做填充序列，增加越来越多数据项，填充序列就越来越长，这叫做聚集。例如上图中的位置5-9中数据。这个时候就需要思考一个问题，如果数据大量聚集的话，会怎么样呢？对于线性探测来说，查找和插入的一个数据项就会花费更多的时间，事实上对于一个存储大量数据的哈希表来说，此时的效率非常低。
2.二次探测
在线性探测的方法中，易发生聚集。一旦聚集形成，它就会越来越大。那些后来哈希化后的落在聚集范围周围的数据，都要一步步移动，并且插入到聚集的最后，因此聚集再一次变大。聚集越大，会有更多的数据落在这个范围内，就这样会形成恶性循环，极大地影响哈希表的效率。
已填入哈希表中的数据项和表长的比率称为装填因子。有10000个数据，如果填入6667个数据，那么他的装填因子就是2/3。当装填因子不太大时，聚集就会比较连贯。哈希表的某个部分可能包含大量的聚集，而另一部分可能还很稀疏。
二次探测是防止聚集的一种尝试（并不能解决全部的聚集问题），思想不再是顺序探测下一个位置，而是间隔的探测下一个位置。如果原始下标是x，那么在线性探测中，探测的位置为x，x+1，x+2。。。；而在二次探测中探测的则是x+1,x+4，x+9。。。
二次探测消除了在线性探测中产生的聚集问题，这种聚集问题叫做原始聚集。可是我们想一想插入一些特殊的数据时：5，15，25，35。。。之类的数据，就会发现在探测空位置时，它们的探测的顺序总是一样的，这种情况也是一种聚集，只不过相比于线性探测，它更加不容易产生，这种现象叫做二次聚集。
3.再哈希法
为了消除原始聚集和二次聚集，可以使用另一个方法：再哈希法。
在再哈希法中，是把第一次产生的由哈希函数产生的哈希值（第一个数组下标），使用另一个哈希函数再次哈希化，得到的另一个新的值，来作为探测的步长。第二个哈希函数必须具备两个特点：1.和第一个哈希函数不同。2.不能输出为零（否则将没有步长，每次探测都会是相同位置）。专家们发现下面形式的哈希函数工作的非常好：stepSize = constant * （key % constant）；其中constant是质数，且小于数组容量。例如：stepSize = 5 * (key % 5)。示例：
对于上面的例子：当我们插入5、75、45 时，5插入到下标为5的位置中（这里的二次哈希的函数用的是上面的示例），但是75用再哈希法得到的探测步长却为0，45得到的探测步长为也为0，这无疑不是一个好消息。此时就牵扯到另一个问题：数组的容量选取。对于哈希表中的容量，应该总是选取一个质数，例如上面的数组长度应该选取11来代替10（后面的例子就用数组长度11）。如果数组容量不是质数，就容易出现上面的探测步长为0情况，那么探测步长就会变得无限长。
如果此时用数组容量11来代替数组容量10 。插入5、75、45时，75得到的探测步长是20，45得到的探测步长为5。（如果只使用再哈希化法，在constant选取5时，对于除了第一次哈希为5的，剩下哈希化为5的插入就会报错）。
二、链地址法
在开放地址法中，通过在哈希表中寻找到一个空位来解决冲突问题。另一个方法是在哈希表中的每个单元中设置链表，某个数据项的关键字值还是像往常一样映射到哈希表的单元中，而数据项本身则插入到链表中。其他的产生冲突的数据项只需要加到链表中就可以了，不再去寻找空位。
三、代码实现哈希表（java实现）
开放地址法：
定义的数据类：
/*
* 存储的数据类
*/
public class DataItem {
private int iData;
public DataItem(int i){
iData = i;
}
public int getkey(){
return iData;
}
}
线性探测和二次探测的只有一点点区别、这里贴出线性探测的代码：
package hash;
/*
*******************顺序哈希算法 *******************
*/
public class HashTable {
private DataItem[] hashArray;
private int arraySize;
private DataItem nonItem;
//结构体
public HashTable(int size){
arraySize = size;
hashArray = new DataItem[arraySize];
nonItem = new DataItem(-1);
}
//显示哈希表
public void displayTable(){
System.out.print("Table: ");
for (int j = 0; j < arraySize; j++) {
if (hashArray[j]!=null) {
System.out.print(hashArray[j].getkey()+" ");
}else {
System.out.print("** ");
}
}
System.out.println("");
}
//hashFunc
public int hashFunc(int key){
return key%arraySize;
}
//insert
public void insert(DataItem item) {
int key = item.getkey();
int hashVal = hashFunc(key);
while(hashArray[hashVal]!=null&&hashArray[hashVal].getkey()!=-1){
++hashVal;
hashVal %= arraySize;
}
hashArray[hashVal] = item;
}
//delete
public DataItem delete(int key){
int hashVal = hashFunc(key);
while(hashArray[hashVal]!=null){
if (hashArray[hashVal].getkey()==key) {
DataItem temp = hashArray[hashVal];
hashArray[hashVal] = nonItem;
return temp;
}
++hashVal;
hashVal %= arraySize;
}
return null;
}
//find
public DataItem find(int key){
int hashVal = hashFunc(key);
while(hashArray[hashVal]!=null){
if (hashArray[hashVal].getkey()==key) {
DataItem temp = hashArray[hashVal];
return temp;
}
++hashVal;
hashVal %= arraySize;
}
return null;
}
}
再哈希法：
package hashDouble;
/*
* 哈希表的使用：再哈希存储
*/
public class HashTable {
private DataItem[] hashArray;
private int arraySize;
private DataItem nonItem;
//contruct
public HashTable(int size){
arraySize = size;
hashArray = new DataItem[arraySize];
nonItem = new DataItem(-1);
}
//displayTable
public void displayTable(){
System.out.print("Table: ");
for (int i = 0; i < arraySize; i++) {
if (hashArray[i]!=null) {
System.out.print(hashArray[i].getKey() + " ");
}else {
System.out.print("** ");
}
}
}
//hashFuc
public int hashFuc(int key){
return key%arraySize; //arraySize为哈希表的长度
}
public int hashFuc2(int key){
return 5-key%5;
}
//insert
public void insert(int key, DataItem item){
int hashVal = hashFuc(key);
int stepSize = hashFuc2(key);
while (hashArray[hashVal]!=null&&hashArray[hashVal].getKey()!=-1) {
hashVal += stepSize;
hashVal %=arraySize;
}
hashArray[hashVal]=item;
}
//delete
public DataItem delete(int key){
int hashVal = hashFuc(key);
int stepSize = hashFuc2(key);
while (hashArray[hashVal]!=null) {
if (hashArray[hashVal].getKey()==key) {
DataItem temp = hashArray[hashVal];
hashArray[hashVal]=nonItem;
return temp;
}
hashVal += stepSize;
hashVal %= arraySize;
}
return null;
}
//find
public DataItem find(int key){
int hashVal = hashFuc(key);
int stepSize = hashFuc2(key);
while (hashArray[hashVal]!=null) {
if (hashArray[hashVal].getKey()==key) {
return hashArray[hashVal];
}
hashVal += stepSize;
hashVal %= arraySize;
}
return null;
}
}
操作Mian主类（看下方）
链地址法较为复杂，希望大家能好好看看：
数据类：
package linkHash;
/*
* 定义的链表中存储的数据
*/
public class Link {
private int iData;
public Link next;
public Link(int item){
iData = item;
}
public int getKey(){
return iData;
}
public void disPlayItem(){
System.out.print(iData + " ");
}
}
链表的定义：
package linkHash;
/*
* 排序链表的实现
*/
public class SortedList {
private Link first;
//构造体
public SortedList(){
first = null;
}
//插入链表
public void insert(Link theLink){
int key = theLink.getKey();
Link previous = null;
Link current = first;
while (current != null && key > current.getKey()) {
previous = current;
current = current.next;
}
if (previous == null) {
first = theLink;
}else{
previous.next = theLink;
}
theLink.next = current;
}
//删除链表
public void delete(int key) {
Link previous = null;
Link current = first;
while(current!=null && key != current.getKey()){
previous = current;
current = current.next;
}
if (previous == null) {
first = first.next;
}else {
previous.next = current.next;
}
}
//find
public Link find(int key){
Link current = first;
while (current != null && key >= current.getKey()) {
if (current.getKey()==key) {
return current;
}
current = current.next;
}
return null;
}
//displayList
public void displayList(){
Link current = first;
System.out.print("List(first--->last):");
while (current != null) {
current.disPlayItem();
current = current.next;
}
System.out.println("");
}
}
哈希表的定义：
package linkHash;
public class HashTable {
private SortedList[] hashList;
private int arraySize;
//HashTable()
public HashTable(int size){
arraySize = size;
hashList = new SortedList[arraySize];
for (int j = 0; j < arraySize; j++) {
hashList[j] = new SortedList();
}
}
//hashFunc
public int hashFunc(int key) {
return key%arraySize;
}
//insert
public void insert(Link theLink){
int key = theLink.getKey();
int hashVal = hashFunc(key);
hashList[hashVal].insert(theLink);
}
//delete
public void delete(int key){
int hashVal = hashFunc(key);
hashList[hashVal].delete(key);
}
//find
public Link find(int aKey){
int hashVal = hashFunc(aKey);
Link theLink = hashList[hashVal].find(aKey);
return theLink;
}
//displayTable
public void displayTable(){
for (int j = 0; j < arraySize; j++) {
System.out.print(j + ".");
hashList[j].displayList();
}
}
}
操作主类：
package linkHash;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class linkHashApp {
public static void main(String[] args) throws IOException {
int aKey;
Link aDataItem;
int size,n,keysPerCell = 100;
System.out.print("Enter size of hash table:");
size = getInt();
System.out.print("Enter initial number of items:");
n = getInt();
HashTable theHashTable = new HashTable(size);
for (int j = 0; j < n; j++) {
aKey = (int)(java.lang.Math.random() * keysPerCell * size);
aDataItem = new Link(aKey);
theHashTable.insert(aDataItem);
}
while (true) {
System.out.print("Enter first letter of show, insert, delete, find:");
char choice = getChar();
switch (choice) {
case ‘s‘:
theHashTable.displayTable();
break;
case ‘i‘:
System.out.print("Enter a key to insert:");
aKey = getInt();
aDataItem = new Link(aKey);
theHashTable.insert(aDataItem);
break;
case ‘d‘:
System.out.print("Enter a key to delete:");
aKey = getInt();
theHashTable.delete(aKey);
break;
case ‘f‘:
System.out.println("Enter a key to find:");
aKey = getInt();
aDataItem = theHashTable.find(aKey);
if (aDataItem != null) {
System.out.println("Found " + aKey);
}else{
System.out.println("Can‘t found " + aKey);
}
break;
default:
break;
}
}
}
public static String getString() throws IOException{
InputStreamReader in = new InputStreamReader(System.in);
BufferedReader buff = new BufferedReader(in);
String s = buff.readLine();
return s;
}
public static int getInt() throws IOException {
return Integer.parseInt(getString());
}
public static char getChar() throws IOException{
return getString().charAt(0);
}
}
---------------------------------------------------------------------------------------------------------------
总结所得，里面有什么谬误的地方，欢迎大家指正。如果有什么建议和看法，欢迎大家留言。