俄罗斯贵宾会-俄罗斯贵宾会官网
做最好的网站

Hashtable、Dictionary、SortedDictionary、SortedList的比较应用

Dictionary和hashtable用法有点相似,他们都是基于键值对的数据集合,但实际上他们内部的实现原理有很大的差异,

学习下解析Hashtable、Dictionary、SortedDictionary、SortedList的比较应用。

先简要概述一下他们主要的区别,稍后在分析Dictionary内部实现的大概原理。

下面深入地分析如题的4个字典的原理。

区别:

我们先看Hashtable

  1. Dictionary支持泛型,而Hashtable不支持。
  2. Dictionary没有装填因子(Load Facto)概念,当容量不够时才扩容(扩容跟Hashtable一样,也是两倍于当前容量最小素数,比如当前数组长度是3,那么新数组长度为7(2x3=6,比6大的最小素数是7),Hashtable是“已装载元素”与”bucket数组长度“大于装载因子时扩容。
  3. Dictionary内部的存储value的数组按先后插入的顺序排序,Hashtable不是。
  4. 当不发生碰撞时,查找Dictionary需要进行两次索引定位,Hashtable需一次,。

    Dictionary采用除法散列法来计算存储地址,想详细了解的可以百度一下,简单来说就是其内部有两个数组:buckets数组和entries数组(entries是一个Entry结构数组),entries有一个next用来模拟链表,该字段存储一个int值,指向下一个存储地址(实际就是bukets数组的索引),当没有发生碰撞时,该字段为-1,发生了碰撞则存储一个int值,该值指向bukets数组.

MSDN的解释:表示键/值对的集合,这些键/值对根据键的哈希代码进行组织。

内部实现

下面跟上次一样,按正常使用Dictionary时,看内部是如何实现的。

  1. 实例化一个Dictionary
Dictionary<string,string> dic=new Dictionary<string,string>();
  • 调用Dictionary默认无参构造函数。
  • 初始化Dictionary内部数组容器:buckets int[]和entries<T,V>[],分别分配长度3。(内部有一个素数数组:3,7,11,17....如图:);
  1. 向dic添加一个值,dic.add("a","abc");
  • a, 将bucket数组和entries数组扩容3个长度。
  • b, 计算"a"的哈希值,
  • c, 然后与bucket数组长度(3)进行取模计算,假如结果为:2
  • d, 因为a是第一次写入,则自动将a的值赋值到entriys[0]的key,同理将"abc"赋值给entriys[0].value,将上面b步骤的哈希值赋值给entriys[0].hashCode,
    entriys[0].next赋值为-1,hashCode赋值b步骤计算出来的哈希值。
  • e, 在bucket[2]存储0。
  1. 通过key获取对应的value, var v=dic["a"];
  • a, 先计算"a"的哈希值,假如结果为2,
  • b,根据上一步骤结果,找到buckets数组索引为2上的值,假如该值为0.
  • c, 找到到entriys数组上索引为0的key,
    • 如果该key值和输入的的“a”字符相同,则对应的value值就是需要查找的值。
    • 如果该key值和输入的"a"字符不相同,说明发生了碰撞,这时获取对应的next值,根据next值定位buckets数组(buckets[next]),然后获取对应buckets上存储的值在定位到entriys数组上,......,一直到找到为止。
    • 如果该key值和输入的"a"字符不相同并且对应的next值为-1,则说明Dictionary不包含字符“a”。

Dictionary里的其他方法就不说了,各位可以自己去看源码,下面来通过实验来对比Hashtable和Dictionary的添加和查找性能,

Hash算法是把任意长度的输入(又叫做预映射, pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不 同的输入可能会散列成相同的输出,而不可能从散列值来唯一的确定输入值。

Hashtable 对象由包含集合元素的存储桶组成。存储桶是 Hashtable 中各元素的虚拟子组,与大多数集合中进行的搜索和检索相比,存储桶 可令搜索和检索更为便捷。每一存储桶都与一个哈希代码关联,该哈希代码是使用哈希函数生成的并基于该元素的键。

Hashtable 类默认的装填因子是 1.0,但实际上它默认的装填因子是 0.72。所有从构造函数输入的装填因子,Hashtable 类内部都会将其乘以0.72。这是一个要求苛刻的数字, 某些时刻将装填因子增减 0.01, 可能你的 Hashtable 存取效率就提高或降低了 50%,其原因是装填因子决定散列表容量,而散列表容量又影响 Key 的冲突几率,进而影响性能。0.72 是 Microsoft经过大量实验得出的一个比较平衡的值。

我们看Hashtable的一些源码:

俄罗斯贵宾会 1 Hashtable .ctor [http://www.xueit.com]

public Hashtable() : this(0, (float) 1f)
{
}
public Hashtable(int capacity, float loadFactor)
{
if (capacity <0)
{
thrownew ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if ((loadFactor <0.1f) || (loadFactor > 1f))
{
thrownew ArgumentOutOfRangeException("loadFactor", Environment.GetResourceString("ArgumentOutOfRange_HashtableLoadFactor", newobject[] { 0.1, 1.0 }));
}
this.loadFactor =0.72f* loadFactor;
double num = ((float) capacity) /this.loadFactor;
if (num >2147483647.0)
{
thrownew ArgumentException(Environment.GetResourceString("Arg_HTCapacityOverflow"));
}
int num2 = (num >11.0) ? HashHelpers.GetPrime((int) num) : 11;
this.buckets =new bucket[num2];
this.loadsize = (int) (this.loadFactor * num2);
this.isWriterInProgress =false;
}

Hashtable 扩容是个耗时非常惊人的内部操作,它之所以写入效率仅为读取效率的 1/10 数量级,频繁的扩容是一个因素。当进行扩容时,散列表内部要重新 new 一个更大的数组,然后把原来数组的内容拷贝到新数组,并进行重新散列。如何 new这个更大的数组也有讲究。散列表的初始容量一般来讲是个素数。当扩容时,新数组的大小会设置成原数组双倍大小的相近的一个素数。

 

俄罗斯贵宾会 2 Hashtable expand [http://www.xueit.com]

privatevoid expand()
{
int prime = HashHelpers.GetPrime(this.buckets.Length *2);
this.rehash(prime);
}
privatevoid rehash(int newsize)
{
this.occupancy =0;
Hashtable.bucket[] newBuckets =new Hashtable.bucket[newsize];
for (int i =0; i <this.buckets.Length; i )
{
Hashtable.bucket bucket =this.buckets[i];
if ((bucket.key !=null) && (bucket.key !=this.buckets))
{
this.putEntry(newBuckets, bucket.key, bucket.val, bucket.hash_coll &0x7fffffff);
}
}
Thread.BeginCriticalRegion();
this.isWriterInProgress =true;
this.buckets = newBuckets;
this.loadsize = (int) (this.loadFactor * newsize);
this.UpdateVersion();
this.isWriterInProgress =false;
Thread.EndCriticalRegion();
}

HashTable数据结构存在问题:空间利用率偏低、受填充因子影响大、扩容时所有的数据需要重新进行散列计算。虽然Hash具有O(1)的数据检索效率,但它空间开销却通常很大,是以空间换取时间。所以Hashtable适用于读取操作频繁,写入操作很少的操作类型。

Dictionary<K, V> 也是用的Hash算法,通过数组实现多条链式结构。不过它是采用分离链接散列法。采用分离链接散列法不受到装填因子的影响,扩容时原有数据不需要重新进行散列计算。

采用分离链接法的 Dictionary<TKey, TValue> 会在内部维护一个链表数组。对于这个链表数组 L0,L1,...,LM-1, 散列函数将告诉我们应当把元素 X 插入到链表的什么位置。然后在 find 操作时告诉我们哪一个表中包含了 X。 这种方法的思想在于:尽管搜索一个链表是线性操作,但如果表足够小,搜索非常快(事实也的确如此,同时这也是查找,插入,删除等操作并非总是 O(1) 的原因)。特别是,它不受装填因子的限制。
这种情况下,常见的装填因子是 1.0。更低的装填因子并不能明显的提高性能,但却需要更多的额外空间。

俄罗斯贵宾会 3 Dictionary .ctor [http://www.xueit.com]

public Dictionary() : this(0, null)
{
}
public Dictionary(int capacity, IEqualityComparer<TKey> comparer)
{
if (capacity <0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
}
if (capacity >0)
{
this.Initialize(capacity);
}
if (comparer ==null)
{
comparer = EqualityComparer<TKey>.Default;
}
this.comparer = comparer;
}
privatevoid Resize()
{
int prime = HashHelpers.GetPrime(this.count *2);
int[] numArray =newint[prime];
for (int i =0; i < numArray.Length; i )
俄罗斯贵宾会,{
numArray[i] =-1;
}
Entry<TKey, TValue>[] destinationArray =new Entry<TKey, TValue>[prime];
Array.Copy(this.entries, 0, destinationArray, 0, this.count);
for (int j =0; j <this.count; j )
{
int index = destinationArray[j].hashCode % prime;
destinationArray[j].next = numArray[index];
numArray[index] = j;
}
this.buckets = numArray;
this.entries = destinationArray;
}

Dictionary的插入算法:1、计算key的hash值,并且找到buckets中目标桶的链首索引,2、从链上依次查找是否key已经保存,3、如果没有的话,判断是否存在freeList,4、如果存在freeList,从freeList上摘下结点保存数据,否则追加在count位置上。

 

俄罗斯贵宾会 4 Dictionary Add [http://www.xueit.com]

privatevoid Insert(TKey key, TValue value, bool add)
{
int freeList;
if (key ==null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
}
if (this.buckets ==null)
{
this.Initialize(0);
}
int num =this.comparer.GetHashCode(key) &0x7fffffff;
int index = num %this.buckets.Length;
for (int i =this.buckets[index]; i >=0; i =this.entries[i].next)
{
if ((this.entries[i].hashCode == num) &&this.comparer.Equals(this.entries[i].key, key))
{
if (add)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
}
this.entries[i].value = value;
this.version ;
return;
}
}
if (this.freeCount >0)
{
freeList =this.freeList;
this.freeList =this.entries[freeList].next;
this.freeCount--;
}
else
{
if (this.count ==this.entries.Length)
{
this.Resize();
index = num %this.buckets.Length;
}
freeList =this.count;
this.count ;
}
this.entries[freeList].hashCode = num;
this.entries[freeList].next =this.buckets[index];
this.entries[freeList].key = key;
this.entries[freeList].value = value;
this.buckets[index] = freeList;
this.version ;
}

buckets数组保存所有数据链的链首,Buckets[i]表示在桶i中数据链的链首元素。entries结构体数组用于保存实际的数据,通过next值作为链式结构的向后索引。删除的数据空间会被串入到freeList链表的首部,当再次插入数据时,会首先查找freeList链表,以提高查找entries中空闲数据项位置的效率。在枚举器中,枚举顺序为entries数组的下标递增顺序。

俄罗斯贵宾会 5 Dictionary Remove [http://www.xueit.com]

publicbool Remove(TKey key)
{
if (key ==null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
}
if (this.buckets !=null)
{
int num =this.comparer.GetHashCode(key) &0x7fffffff;
int index = num %this.buckets.Length;
int num3 =-1;
for (int i =this.buckets[index]; i >=0; i =this.entries[i].next)
{
if ((this.entries[i].hashCode == num) &&this.comparer.Equals(this.entries[i].key, key))
{
if (num3 <0)
{
this.buckets[index] =this.entries[i].next;
}
else
{
this.entries[num3].next =this.entries[i].next;
}
this.entries[i].hashCode =-1;
this.entries[i].next =this.freeList;
this.entries[i].key =default(TKey);
this.entries[i].value =default(TValue);
this.freeList = i;
this.freeCount ;
this.version ;
returntrue;
}
num3 = i;
}
}
returnfalse;
}

 

 

本文由俄罗斯贵宾会发布于编程,转载请注明出处:Hashtable、Dictionary、SortedDictionary、SortedList的比较应用

您可能还会对下面的文章感兴趣: