哈希表(散列表)

一、定义 

哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。

也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

哈希表的做法其实很简单，就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。
而当使用哈希表进行查询的时候，就是再次使用哈希函数将key转换为对应的数组下标，并定位到该空间获取value，如此一来，就可以充分利用到数组的定位性能进行数据定位。

比如：有一个很大的有序数组，想要得到位于该数组第n个位置的值，它的算法复杂度为O(1)。

哈希表利用哈希函数将需要存储的内容的关键值转换为这个有序数组中的某个值，在被存储内容和有序数组之间建立了映射关系。这样，下次我们对这个值进行查找时只要使用同一个哈希函数对关键值进行转换，找到这个数组值 就可以了。

      如果还没有明白是怎么回事的话，那我们来举个例子。假设我们要做个存储结构，需要存储下来三国中的人物，以及他们的详细信息。我们用他们的名字来作为存储 的关键值，例如：刘备，曹操，孙权，关羽，张飞……等等。这个时候我们如果想用一般的方法来查找这些英雄豪杰，需要遍历整个存储空间，如果这些英雄豪杰一 共有n个，那么这时候的时间算法复杂度为O(n)。显然如果n值很大，每次想要找到某个英雄就需要比较长的时间。
      此时我们先定义一个大的有序结构数组HashValue[m]，用来存放各位英雄豪杰的信息。然后编写一个哈希函数ChangeToHashValue (name)，函数的具体内容就不细说了，反正这个函数会将这些做为关键值的名字转换为HashValue[m]中的某个下标值x。然后可以将英雄的信息 放进HashValue[x]中去。这样，可以将所有英雄的信息存储起来。当查询的时候再使用哈希函数ChangeToHashValue(name)得 到这个下标值，这样就很容易得到了这个英雄的信息。例如：ChangeToHashValue(刘备)为10，那么就将刘备存储到HashValue [10]里面。当查询的时候再次使用ChangeToHashValue(刘备)得到10，这个时候我们就可以很容易找到刘备的所有信息。在实际应用中如 果我们想把所有的英雄豪杰都存储进系统时，需要定义m>n。就是数组的大小要大于需要存储的信息量，所以说哈希表是一个以空间换取时间的数据结构。
      这个时候问题来了，出现了这种情况ChangeToHashValue(关羽)和ChangeToHashValue(张飞)得到的值是一样的，都是 250，我们岂不是在存储过程中会遇到麻烦，怎么安排他们二位的地方呢（总不能让二位打一架，谁赢了谁呆在那吧），这就需要一个解决冲突的方法。当遇到这 种情况时我们可以这样处理，先存储好了关羽，当张飞进入系统时会发现关羽已经是250了，那咱就加一位，251得了，这不就解决了。我们查找张飞的时候也 是，一看250不是张飞，那就加个1，就找到了。这时还存在一个问题。直接用ChangeToHashValue(赵云)为251，张飞已经早早占了他的 地方，那就再加1存到252呗。呵呵，这时我们会发现，当哈希函数冲突发生的机率很高时，可能会有一群英雄豪杰在250这个值后面扎堆排队。要命的是查找 的时候，时间算法复杂度早已不是O(1)了（所以我们说理想情况下哈希表的时间算法复杂度为O(1)）。      

这就是说哈希函数的编写是哈希表的一个关键问题，会涉及到一个存储值在哈希表中的统计分布。如果哈希函数已经定义好了，冲突的解决就成为了改变系统性能的关键因素。其实还有很多种方法来解决冲突情况下的存储和查找问题，不一定非要线性向后排队，如果有好的哈希表冲突的解决方法也能很大程度上提高系统的效 率。

二、

1 基本原理
  使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数， 也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素"分类"，然后将这个元素存储在相应"类"所对应的地方。

  但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了"冲突"，换句话说，就是把不同的元素分在了相同的"类"之中。后面我们将看到一种解决"冲突"的简便做法。

  总的来说，"直接定址"与"解决冲突"是哈希表的两大特点。

2 函数构造

  构造函数的常用方法（下面为了叙述简洁，设 h(k) 表示关键字为 k 的元素所对应的函数值）：

  a) 除余法：

  选择一个适当的正整数 p ，令 h(k ) = k mod p 
  这里， p 如果选取的是比较大的素数，效果比较好。而且此法非常容易实现，因此是最常用的方法。

  b) 数字选择法：

  如果关键字的位数比较多，超过长整型范围而无法直接运算，可以选择其中数字分布比较均匀的若干位，所组成的新的值作为关键字或者直接作为函数值。

3 冲突处理

  线性重新散列技术易于实现且可以较好的达到目的。令数组元素个数为 S ，则当 h(k) 已经存储了元素的时候，依次探查 (h(k)+i) mod S , i=1,2,3…… ，直到找到空的存储单元为止（或者从头到尾扫描一圈仍未发现空单元，这就是哈希表已经满了，发生了错误。当然这是可以通过扩大数组范围避免的）。

4 支持运算

  哈希表支持的运算主要有：初始化(makenull)、哈希函数值的运算(h(x))、插入元素(insert)、查找元素(member)。
  设插入的元素的关键字为 x ，A 为存储的数组。
  初始化比较容易，例如
  const empty=maxlongint; // 用非常大的整数代表这个位置没有存储元素
     p=9997;      // 表的大小
  procedure makenull;
   var i:integer;
   begin
    for i:=0 to p-1 do
     A[i]:=empty;
   End;

  哈希函数值的运算根据函数的不同而变化，例如除余法的一个例子：
  function h(x:longint):Integer;
   begin
    h:= x mod p;
   end;

  我们注意到，插入和查找首先都需要对这个元素定位，即如果这个元素若存在，它应该存储在什么位置，因此加入一个定位的函数 locate 
  function locate(x:longint):integer;
   var orig,i:integer;
   begin
    orig:=h(x);
    i:=0;
    while (i<S)and(A[(orig+i)mod S]<>x)and(A[(orig+i)mod S]<>empty) do
     inc(i); 
     //当这个循环停下来时，要么找到一个空的存储单元，要么找到这个元
     //素存储的单元，要么表已经满了
    locate:=(orig+i) mod S;
   end;
  插入元素
  procedure insert(x:longint);
   var posi:integer;
   begin
    posi:=locate(x);      //定位函数的返回值
    if A[posi]=empty then A[posi]:=x
          else error; //error 即为发生了错误，当然这是可以避免的
   end; 

  查找元素是否已经在表中
  procedure member(x:longint):boolean;
    var posi:integer; 
    begin
     posi:=locate(x);
     if A[posi]=x then member:=true
             else member:=false;
    end;

  这些就是建立在哈希表上的常用基本运算。

三、应用

查找一个数组中重复最多的项 

比如[1,12,4,5,6,7,11,1,1,2,2,2,6]   这里1和2都重复了3次 

1.先排序,O(n*log(n))  然后在遍历一次O(n)

输出的是一个列表,显示的是原来列表里面的每个数出现的次数.

var _array:Array=[1,12,4,5,6,7,11,1,1,2,2,2,6];
var _total:Array=new Array();
for (var i:int=0; i<_array.length; i++) {
        _total[i]=0;
        for (var j:int=0; j<_array.length; j++) {
                if (_array[i]==_array[j]) {
                        _total[i]=_total[i]+1;
                }
        }
}
trace(_total);

2.最快的就是使用哈希表（Hash Table），复杂度为O(n)-O(1)，计算为O(n)，读取为O(1)

var maxid:int = 0;
for (var i:int = 0; i<=n; i++)
{
  num[a[i]]++;
  if (num[a[i]]>maxid) maxid = i;
}
trace(a[maxid]);